src/SketchSolver/SketchSolver_Builder.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:    SketchSolver_Builder.cpp
   4 // Created: 25 Mar 2015
   5 // Author:  Artem ZHIDKOV
   6
   7 #include "SketchSolver_Builder.h"
   8 #include <SketchSolver_Constraint.h>
   9 #include <SketchSolver_ConstraintAngle.h>
  10 #include <SketchSolver_ConstraintCoincidence.h>
  11 #include <SketchSolver_ConstraintDistance.h>
  12 #include <SketchSolver_ConstraintEqual.h>
  13 #include <SketchSolver_ConstraintFixed.h>
  14 #include <SketchSolver_ConstraintLength.h>
  15 #include <SketchSolver_ConstraintMirror.h>
  16 #include <SketchSolver_ConstraintTangent.h>
  17 #include <SketchSolver_ConstraintMultiRotation.h>
  18 #include <SketchSolver_ConstraintMultiTranslation.h>
  19 #include <SketchSolver_ConstraintMovement.h>
  20
  21 #ifdef _DEBUG
  22 #include <Events_Error.h>
  23 #include <ModelAPI_AttributeRefList.h>
  24 #include <ModelAPI_ResultConstruction.h>
  25 #include <SketchSolver_Error.h>
  26 #endif
  27
  28 #include <SketchPlugin_ConstraintAngle.h>
  29 #include <SketchPlugin_ConstraintCoincidence.h>
  30 #include <SketchPlugin_ConstraintDistance.h>
  31 #include <SketchPlugin_ConstraintEqual.h>
  32 #include <SketchPlugin_ConstraintLength.h>
  33 #include <SketchPlugin_ConstraintMirror.h>
  34 #include <SketchPlugin_ConstraintRigid.h>
  35 #include <SketchPlugin_ConstraintTangent.h>
  36 #include <SketchPlugin_MultiRotation.h>
  37 #include <SketchPlugin_MultiTranslation.h>
  38
  39 #include <math.h>
  40
  41 SolverConstraintPtr SketchSolver_Builder::createConstraint(ConstraintPtr theConstraint) const
  42 {
  43   SolverConstraintPtr aResult;
  44   DataPtr aData = theConstraint->data();
  45   if (!aData || !aData->isValid())
  46     return aResult;
  47
  48 #ifdef _DEBUG
  49   // Verify attributes of constraint and generate errors
  50   std::list<AttributePtr> anAttrList = aData->attributes(std::string());
  51   std::list<AttributePtr>::iterator anIter = anAttrList.begin();
  52   for (; anIter != anAttrList.end(); anIter++) {
  53     AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
  54     if (aRefAttr) {
  55       if (aRefAttr->isObject() && aRefAttr->object()) {
  56         ResultConstructionPtr aRC =
  57             std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aRefAttr->object());
  58         if (!aRC)
  59           Events_Error::send(SketchSolver_Error::NEED_OBJECT_NOT_FEATURE(), this);
  60       }
  61       continue;
  62     }
  63     AttributeRefListPtr aRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(*anIter);
  64     if (aRefList) {
  65       std::list<ObjectPtr> aList = aRefList->list();
  66       std::list<ObjectPtr>::iterator aListIter = aList.begin();
  67       for (; aListIter != aList.end(); aListIter++) {
  68         ResultConstructionPtr aRC =
  69             std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aListIter);
  70         if (*aListIter && !aRC)
  71           Events_Error::send(SketchSolver_Error::NEED_OBJECT_NOT_FEATURE(), this);
  72       }
  73     }
  74   }
  75 #endif
  76
  77   if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
  78     return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
  79   } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID()) {
  80     return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
  81   } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
  82     return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
  83   } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
  84     return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
  85   } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
  86     return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
  87   } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
  88     return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
  89   } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
  90     return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
  91   } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
  92     return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
  93   } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
  94     return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
  95   } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
  96     return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
  97   }
  98   // All other types of constraints
  99   return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
 100 }
 101
 102 SolverConstraintPtr SketchSolver_Builder::createFixedConstraint(FeaturePtr theFixedFeature) const
 103 {
 104   DataPtr aData = theFixedFeature->data();
 105   if (!aData || !aData->isValid())
 106     return SolverConstraintPtr();
 107   return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theFixedFeature));
 108 }
 109
 110 SolverConstraintPtr SketchSolver_Builder::createMovementConstraint(FeaturePtr theFixedFeature) const
 111 {
 112   DataPtr aData = theFixedFeature->data();
 113   if (!aData || !aData->isValid())
 114     return SolverConstraintPtr();
 115   return SolverConstraintPtr(new SketchSolver_ConstraintMovement(theFixedFeature));
 116 }
 117
 118 std::shared_ptr<GeomAPI_Pnt2d> SketchSolver_Builder::point(EntityWrapperPtr theEntity) const
 119 {
 120   if (theEntity->type() != ENTITY_POINT)
 121     return std::shared_ptr<GeomAPI_Pnt2d>();
 122
 123   double aXY[2];
 124   std::list<ParameterWrapperPtr> aParams = theEntity->parameters();
 125   std::list<ParameterWrapperPtr>::const_iterator anIt = aParams.begin();
 126   for (int i = 0; i < 2 && anIt != aParams.end(); ++i, ++anIt)
 127     aXY[i] = (*anIt)->value();
 128   if (anIt != aParams.end())
 129     return std::shared_ptr<GeomAPI_Pnt2d>();
 130
 131   return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(aXY[0], aXY[1]));
 132 }
 133
 134 std::shared_ptr<GeomAPI_Lin2d> SketchSolver_Builder::line(EntityWrapperPtr theEntity) const
 135 {
 136   if (theEntity->type() != ENTITY_LINE)
 137     return std::shared_ptr<GeomAPI_Lin2d>();
 138
 139   std::shared_ptr<GeomAPI_Pnt2d> aPoints[2];
 140   std::list<EntityWrapperPtr> aSubs = theEntity->subEntities();
 141   std::list<EntityWrapperPtr>::const_iterator anIt = aSubs.begin();
 142   for (int i = 0; i < 2 && anIt != aSubs.end(); ++i, ++anIt)
 143     aPoints[i] = point(*anIt);
 144   if (anIt != aSubs.end())
 145     return std::shared_ptr<GeomAPI_Lin2d>();
 146
 147   return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aPoints[0], aPoints[1]));
 148 }
 149