#include "SketchPlugin_ConstraintCoincidence.h"
+#include <SketchPlugin_Point.h>
+#include <SketchPlugin_Line.h>
#include <SketchPlugin_Arc.h>
#include <SketchPlugin_Circle.h>
-#include <SketchPlugin_Line.h>
-#include <SketchPlugin_Point.h>
-#include <SketcherPrs_Factory.h>
-
-#include <ModelAPI_AttributeDouble.h>
-#include <ModelAPI_Data.h>
-#include <GeomDataAPI_Dir.h>
-#include <GeomDataAPI_Point.h>
+#include <ModelAPI_Events.h>
+#include <ModelGeomAlgo_Point2D.h>
#include <GeomDataAPI_Point2D.h>
-#include <GeomAPI_Circ2d.h>
-#include <GeomAPI_Dir2d.h>
-#include <GeomAPI_Lin2d.h>
+#include <SketcherPrs_Factory.h>
-/// \brief Update coordinates of the point to be correctly placed on the feature
-static void adjustPointOnEntity(std::shared_ptr<GeomDataAPI_Point2D> thePoint, FeaturePtr theFeature);
+#include <Events_Loop.h>
SketchPlugin_ConstraintCoincidence::SketchPlugin_ConstraintCoincidence()
{
return anAIS;
}
-void SketchPlugin_ConstraintCoincidence::attributeChanged(const std::string& theID)
+FeaturePtr SketchPlugin_ConstraintCoincidence::findCoincidenceFeature(const FeaturePtr& theFeature1,
+ const FeaturePtr& theFeature2)
{
- if (theID == ENTITY_A() || theID == ENTITY_B()) {
- AttributeRefAttrPtr anAttrA =
- std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(attribute(ENTITY_A()));
- AttributeRefAttrPtr anAttrB =
- std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(attribute(ENTITY_B()));
-
- if (!anAttrA || !anAttrB || (!anAttrA->isObject() && !anAttrB->isObject()))
- return;
-
- if (anAttrA->isObject()) {
- AttributeRefAttrPtr aTransient = anAttrA;
- anAttrA = anAttrB;
- anAttrB = aTransient;
- }
-
- std::shared_ptr<GeomDataAPI_Point2D> aPoint =
- std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrA->attr());
- FeaturePtr aFeature;
- if (anAttrB->object())
- aFeature = ModelAPI_Feature::feature(anAttrB->object());
-
- // Adjust position of a point lying on a line or arc
- if (aPoint && aFeature)
- adjustPointOnEntity(aPoint, aFeature);
+ FeaturePtr aResultFeature;
+
+ std::list<AttributePtr> anAttrList;
+ if (theFeature1->getKind() == SketchPlugin_Circle::ID() ||
+ theFeature2->getKind() == SketchPlugin_Circle::ID())
+ return aResultFeature;
+
+ if (theFeature2->getKind() == SketchPlugin_Line::ID()) {
+ anAttrList.push_back(theFeature2->attribute(SketchPlugin_Line::START_ID()));
+ anAttrList.push_back(theFeature2->attribute(SketchPlugin_Line::END_ID()));
+ } else if (theFeature2->getKind() == SketchPlugin_Arc::ID()) {
+ anAttrList.push_back(theFeature2->attribute(SketchPlugin_Arc::START_ID()));
+ anAttrList.push_back(theFeature2->attribute(SketchPlugin_Arc::END_ID()));
}
-}
-
+ const std::set<AttributePtr>& aRefsList = theFeature1->data()->refsToMe();
+ std::set<AttributePtr>::const_iterator aRefIt = aRefsList.begin();
+ for (; aRefIt != aRefsList.end() && !aResultFeature.get(); ++aRefIt) {
+ FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>((*aRefIt)->owner());
+ if (aConstrFeature->getKind() != SketchPlugin_ConstraintCoincidence::ID())
+ continue;
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*aRefIt);
+ AttributePtr anAttr = aRefAttr->attr();
+ if (anAttr->id() == SketchPlugin_Arc::CENTER_ID())
+ continue;
+
+ anAttr = aConstrFeature->attribute(SketchPlugin_Constraint::ENTITY_A());
+ if (anAttr == *aRefIt)
+ anAttr = aConstrFeature->attribute(SketchPlugin_Constraint::ENTITY_B());
+
+ aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttr);
+ if (!aRefAttr)
+ continue;
+ anAttr = aRefAttr->attr();
+ for (std::list<AttributePtr>::const_iterator anIt = anAttrList.begin();
+ anIt != anAttrList.end() && !aResultFeature.get(); ++anIt)
+ if (*anIt == anAttr)
+ aResultFeature = aConstrFeature;
+ }
+ return aResultFeature;
+}
+AttributePoint2DPtr SketchPlugin_ConstraintCoincidence::getPoint(const FeaturePtr& theFeature)
+{
+ AttributePoint2DPtr aPoint = ModelGeomAlgo_Point2D::getPointOfRefAttr(theFeature.get(),
+ SketchPlugin_Constraint::ENTITY_A(),
+ SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID());
+ if (!aPoint.get())
+ aPoint = ModelGeomAlgo_Point2D::getPointOfRefAttr(theFeature.get(),
+ SketchPlugin_Constraint::ENTITY_B(),
+ SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID());
+ return aPoint;
+}
-// ======= Auxiliary functions ================================================
-void adjustPointOnEntity(std::shared_ptr<GeomDataAPI_Point2D> thePoint, FeaturePtr theFeature)
+void SketchPlugin_ConstraintCoincidence::createCoincidenceFeature(SketchPlugin_Sketch* theSketch,
+ const std::shared_ptr<GeomDataAPI_Point2D>& thePoint1,
+ const std::shared_ptr<GeomDataAPI_Point2D>& thePoint2)
{
- if (theFeature->getKind() == SketchPlugin_Line::ID()) {
- // project point on line
- std::shared_ptr<GeomDataAPI_Point2D> aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Line::START_ID()));
- std::shared_ptr<GeomDataAPI_Point2D> aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Line::END_ID()));
-
- std::shared_ptr<GeomAPI_Lin2d> aLine(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
- std::shared_ptr<GeomAPI_Pnt2d> aProjected = aLine->project(thePoint->pnt());
- thePoint->setValue(aProjected);
+ FeaturePtr aFeature;
+ if (theSketch) {
+ aFeature = theSketch->addFeature(SketchPlugin_ConstraintCoincidence::ID());
+ } else {
+ std::shared_ptr<ModelAPI_Document> aDoc = theSketch->document();
+ aFeature = aDoc->addFeature(SketchPlugin_ConstraintCoincidence::ID());
}
- else if (theFeature->getKind() == SketchPlugin_Circle::ID()) {
- // project point on circle
- std::shared_ptr<GeomDataAPI_Point2D> aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Circle::CENTER_ID()));
- double aRadius = theFeature->real(SketchPlugin_Circle::RADIUS_ID())->value();
- std::shared_ptr<GeomAPI_Dir2d> aDir(new GeomAPI_Dir2d(1.0, 0.0));
- std::shared_ptr<GeomAPI_Circ2d> aCircle(new GeomAPI_Circ2d(aCenter->pnt(), aDir, aRadius));
+ std::shared_ptr<ModelAPI_Data> aData = aFeature->data();
- std::shared_ptr<GeomAPI_Pnt2d> aProjected = aCircle->project(thePoint->pnt());
- thePoint->setValue(aProjected);
- }
- else if (theFeature->getKind() == SketchPlugin_Arc::ID()) {
- // project point on arc
- std::shared_ptr<GeomDataAPI_Point2D> aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
- std::shared_ptr<GeomDataAPI_Point2D> aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Arc::START_ID()));
-
- std::shared_ptr<GeomAPI_Circ2d> aCircle(new GeomAPI_Circ2d(aCenter->pnt(), aStart->pnt()));
- std::shared_ptr<GeomAPI_Pnt2d> aProjected = aCircle->project(thePoint->pnt());
- thePoint->setValue(aProjected);
- }
+ std::shared_ptr<ModelAPI_AttributeRefAttr> aRef1 = std::dynamic_pointer_cast<
+ ModelAPI_AttributeRefAttr>(aData->attribute(SketchPlugin_Constraint::ENTITY_A()));
+ aRef1->setAttr(thePoint1);
+
+ std::shared_ptr<ModelAPI_AttributeRefAttr> aRef2 = std::dynamic_pointer_cast<
+ ModelAPI_AttributeRefAttr>(aData->attribute(SketchPlugin_Constraint::ENTITY_B()));
+ aRef2->setAttr(thePoint2);
+
+ // we need to flush created signal in order to coincidence is processed by solver
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
}
