+ FeaturePtr aProjectionFeature = theSketch->addFeature(SketchPlugin_Projection::ID());
+ theCreatedFeature = aProjectionFeature;
+ AttributeSelectionPtr anExternalAttr = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(
+ aProjectionFeature->attribute(SketchPlugin_Projection::EXTERNAL_FEATURE_ID()));
+ anExternalAttr->setValue(aResult, theShape);
+
+ AttributeBooleanPtr anIntoResult = std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>
+ (aProjectionFeature->data()->attribute(SketchPlugin_Projection::INCLUDE_INTO_RESULT()));
+ anIntoResult->setValue(SKETCH_PROJECTION_INCLUDE_INTO_RESULT);
+ aProjectionFeature->execute();
+
+ // if projection feature has not been created, exit
+ AttributeRefAttrPtr aRefAttr = aProjectionFeature->data()->refattr(
+ SketchPlugin_Projection::PROJECTED_FEATURE_ID());
+ if (!aRefAttr || !aRefAttr->isInitialized())
+ {
+ // remove external feature if the attribute is not filled
+ std::set<FeaturePtr> aFeatures;
+ aFeatures.insert(aProjectionFeature);
+ ModelAPI_Tools::removeFeaturesAndReferences(aFeatures);
+ return ResultPtr();
+ }
+
+ FeaturePtr aProjection = ModelAPI_Feature::feature(aRefAttr->object());
+ if (aProjection.get() && aProjection->lastResult().get())
+ return aProjection->lastResult();
+
+ return ResultPtr();
+}
+
+bool PartSet_Tools::isContainPresentation(const QList<ModuleBase_ViewerPrsPtr>& theSelected,
+ const ModuleBase_ViewerPrsPtr& thePrs)
+{
+ foreach (ModuleBase_ViewerPrsPtr aPrs, theSelected) {
+ if (aPrs->object() == thePrs->object())
+ return true;
+ }
+ return false;
+}
+
+GeomShapePtr PartSet_Tools::findShapeBy2DPoint(const AttributePtr& theAttribute,
+ ModuleBase_IWorkshop* theWorkshop)
+{
+ GeomShapePtr aShape;
+ XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(theWorkshop);
+ XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer();
+
+ // 2. find visualized vertices of the attribute and if the attribute of the vertex is
+ // the same, return it
+ FeaturePtr anAttributeFeature = ModelAPI_Feature::feature(theAttribute->owner());
+ // 2.1 get visualized results of the feature
+ const std::list<ResultPtr>& aResList = anAttributeFeature->results();
+ std::list<ResultPtr>::const_iterator anIt = aResList.begin(), aLast = aResList.end();
+ for (; anIt != aLast; anIt++) {
+ AISObjectPtr aAISObj = aDisplayer->getAISObject(*anIt);
+ if (aAISObj.get() != NULL) {
+ Handle(AIS_InteractiveObject) anAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
+ // 2.2 find selected owners of a visualizedd object
+ SelectMgr_IndexedMapOfOwner aSelectedOwners;
+ aConnector->workshop()->selector()->selection()->entityOwners(anAISIO, aSelectedOwners);
+ for (Standard_Integer i = 1, n = aSelectedOwners.Extent(); i <= n; i++) {
+ Handle(SelectMgr_EntityOwner) anOwner = aSelectedOwners(i);
+ if (!anOwner.IsNull()) {
+ Handle(StdSelect_BRepOwner) aBRepOwner = Handle(StdSelect_BRepOwner)::DownCast(anOwner);
+ if (!aBRepOwner.IsNull() && aBRepOwner->HasShape()) {
+ const TopoDS_Shape& aBRepShape = aBRepOwner->Shape();
+ if (aBRepShape.ShapeType() == TopAbs_VERTEX) {
+ // 2.3 if the owner is vertex and an attribute of the vertex is equal to the initial
+ // attribute, returns the shape
+ PartSet_Module* aModule = dynamic_cast<PartSet_Module*>(theWorkshop->module());
+ PartSet_SketcherMgr* aSketchMgr = aModule->sketchMgr();
+ AttributePtr aPntAttr = PartSet_Tools::findAttributeBy2dPoint(anAttributeFeature,
+ aBRepShape, aSketchMgr->activeSketch());
+ if (aPntAttr.get() != NULL && aPntAttr == theAttribute) {
+ aShape = std::shared_ptr<GeomAPI_Shape>(new GeomAPI_Shape);
+ aShape->setImpl(new TopoDS_Shape(aBRepShape));
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return aShape;
+}
+
+std::shared_ptr<GeomAPI_Pnt2d> PartSet_Tools::getPoint(
+ std::shared_ptr<ModelAPI_Feature>& theFeature,
+ const std::string& theAttribute)
+{
+ std::shared_ptr<GeomDataAPI_Point2D> aPointAttr = ModelGeomAlgo_Point2D::getPointOfRefAttr(
+ theFeature.get(), theAttribute, SketchPlugin_Point::ID(),
+ SketchPlugin_Point::COORD_ID());
+ if (aPointAttr.get() != NULL)
+ return aPointAttr->pnt();
+ return std::shared_ptr<GeomAPI_Pnt2d>();
+}
+
+std::shared_ptr<GeomAPI_Pnt2d> PartSet_Tools::getPnt2d(QMouseEvent* theEvent,
+ ModuleBase_IViewWindow* theWindow,
+ const FeaturePtr& theSketch)
+{
+ gp_Pnt aPnt = PartSet_Tools::convertClickToPoint(theEvent->pos(), theWindow->v3dView());
+ double aX, anY;
+ Handle(V3d_View) aView = theWindow->v3dView();
+ PartSet_Tools::convertTo2D(aPnt, theSketch, aView, aX, anY);
+
+ return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(aX, anY));
+}
+
+FeaturePtr findFirstCoincidenceByData(const DataPtr& theData,
+ std::shared_ptr<GeomAPI_Pnt2d> thePoint)
+{
+ FeaturePtr aCoincident;
+
+ const std::set<AttributePtr>& aRefsList = theData->refsToMe();
+ std::set<AttributePtr>::const_iterator aIt;
+ for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
+ std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
+ FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
+ if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
+ std::shared_ptr<GeomAPI_Pnt2d> a2dPnt =
+ PartSet_Tools::getPoint(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_A());
+ if (a2dPnt.get() && thePoint->isEqual(a2dPnt)) {
+ aCoincident = aConstrFeature;
+ break;
+ } else {
+ a2dPnt = PartSet_Tools::getPoint(aConstrFeature,
+ SketchPlugin_ConstraintCoincidence::ENTITY_B());
+ if (a2dPnt.get() && thePoint->isEqual(a2dPnt)) {
+ aCoincident = aConstrFeature;
+ break;
+ }
+ }
+ }
+ }
+ return aCoincident;
+}
+
+FeaturePtr PartSet_Tools::findFirstCoincidence(const FeaturePtr& theFeature,
+ std::shared_ptr<GeomAPI_Pnt2d> thePoint)
+{
+ FeaturePtr aCoincident;
+ if (theFeature.get() == NULL)
+ return aCoincident;
+
+ const std::set<AttributePtr>& aRefsList = theFeature->data()->refsToMe();
+ std::set<AttributePtr>::const_iterator aIt;
+ for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
+ std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
+ FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
+ if (aConstrFeature && aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
+ std::shared_ptr<GeomAPI_Pnt2d> a2dPnt =
+ PartSet_Tools::getPoint(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_A());
+ if (a2dPnt.get() && thePoint->isEqual(a2dPnt)) {
+ aCoincident = aConstrFeature;
+ break;
+ } else {
+ a2dPnt = PartSet_Tools::getPoint(aConstrFeature,
+ SketchPlugin_ConstraintCoincidence::ENTITY_B());
+ if (a2dPnt.get() && thePoint->isEqual(a2dPnt)) {
+ aCoincident = aConstrFeature;
+ break;
+ }
+ }
+ }
+ }
+ /// Find by result
+ if (!aCoincident.get()) {
+ std::list<ResultPtr> aResults = theFeature->results();
+ std::list<ResultPtr>::const_iterator aIt;
+ for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
+ ResultPtr aResult = *aIt;
+ aCoincident = findFirstCoincidenceByData(aResult->data(), thePoint);
+ if (aCoincident.get())
+ break;
+ }
+ }
+ return aCoincident;
+}
+
+void PartSet_Tools::findCoincidences(FeaturePtr theStartCoin, QList<FeaturePtr>& theList,
+ QList<FeaturePtr>& theCoincidencies,
+ std::string theAttr, QList<bool>& theIsAttributes)
+{
+ std::shared_ptr<GeomAPI_Pnt2d> aOrig = getCoincedencePoint(theStartCoin);
+ if (aOrig.get() == NULL)
+ return;
+
+ AttributeRefAttrPtr aPnt = theStartCoin->refattr(theAttr);
+ if (!aPnt)
+ return;
+ ObjectPtr aObj = aPnt->object();
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
+ if (aFeature.get()) {
+ if (!theList.contains(aFeature)) {
+ theList.append(aFeature);
+ theCoincidencies.append(theStartCoin);
+ theIsAttributes.append(true); // point attribute on a feature
+ const std::set<AttributePtr>& aRefsList = aFeature->data()->refsToMe();
+ std::set<AttributePtr>::const_iterator aIt;
+ for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
+ std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
+ FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
+ if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
+ if (!theCoincidencies.contains(aConstrFeature)) {
+ std::shared_ptr<GeomAPI_Pnt2d> aPnt = getCoincedencePoint(aConstrFeature);
+ if (aPnt.get() && aOrig->isEqual(aPnt)) {
+ findCoincidences(aConstrFeature, theList, theCoincidencies,
+ SketchPlugin_ConstraintCoincidence::ENTITY_A(), theIsAttributes);
+ findCoincidences(aConstrFeature, theList, theCoincidencies,
+ SketchPlugin_ConstraintCoincidence::ENTITY_B(), theIsAttributes);
+ }
+ }
+ }
+ }
+ }
+ } else {
+ // Find by Results
+ ResultConstructionPtr aResult = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aObj);
+ if (aResult.get()) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(aPnt->object());
+ if (!theList.contains(aFeature))
+ theList.append(aFeature);
+ theCoincidencies.append(theStartCoin);
+ theIsAttributes.append(false); // point attribute on a feature
+
+ const std::set<AttributePtr>& aRefsList = aResult->data()->refsToMe();
+ std::set<AttributePtr>::const_iterator aIt;
+ for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
+ std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
+ FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
+ if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
+ if (!theCoincidencies.contains(aConstrFeature)) {
+ std::shared_ptr<GeomAPI_Pnt2d> aPnt = getCoincedencePoint(aConstrFeature);
+ if (aPnt.get() && aOrig->isEqual(aPnt)) {
+ findCoincidences(aConstrFeature, theList, theCoincidencies,
+ SketchPlugin_ConstraintCoincidence::ENTITY_A(), theIsAttributes);
+ findCoincidences(aConstrFeature, theList, theCoincidencies,
+ SketchPlugin_ConstraintCoincidence::ENTITY_B(), theIsAttributes);
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+std::shared_ptr<GeomAPI_Pnt2d> PartSet_Tools::getCoincedencePoint(FeaturePtr theStartCoin)
+{
+ std::shared_ptr<GeomAPI_Pnt2d> aPnt = SketcherPrs_Tools::getPoint(theStartCoin.get(),
+ SketchPlugin_Constraint::ENTITY_A());
+ if (aPnt.get() == NULL)
+ aPnt = SketcherPrs_Tools::getPoint(theStartCoin.get(), SketchPlugin_Constraint::ENTITY_B());
+ return aPnt;
+}
+
+AttributePtr PartSet_Tools::findAttributeBy2dPoint(ObjectPtr theObj,
+ const TopoDS_Shape theShape,
+ FeaturePtr theSketch)
+{
+
+ AttributePtr anAttribute;
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theObj);
+ if (aFeature) {
+ if (theShape.ShapeType() == TopAbs_VERTEX) {
+ const TopoDS_Vertex& aVertex = TopoDS::Vertex(theShape);
+ if (!aVertex.IsNull()) {
+ gp_Pnt aPoint = BRep_Tool::Pnt(aVertex);
+ std::shared_ptr<GeomAPI_Pnt> aValue = std::shared_ptr<GeomAPI_Pnt>(
+ new GeomAPI_Pnt(aPoint.X(), aPoint.Y(), aPoint.Z()));
+
+ // find the given point in the feature attributes
+ std::list<AttributePtr> anAttiributes =
+ aFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+ std::list<AttributePtr>::const_iterator anIt = anAttiributes.begin(),
+ aLast = anAttiributes.end();
+ for (; anIt != aLast && !anAttribute; anIt++) {
+ std::shared_ptr<GeomDataAPI_Point2D> aCurPoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(*anIt);
+ if (!aCurPoint->isInitialized())
+ continue;
+
+ std::shared_ptr<GeomAPI_Pnt> aPnt =
+ convertTo3D(aCurPoint->x(), aCurPoint->y(), theSketch);
+ if (aPnt && (aPnt->distance(aValue) < Precision::Confusion())) {
+ anAttribute = aCurPoint;
+ break;
+ }
+ }
+ }