X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_Tools.cpp;h=f7c4ab57f0c6fde0261324b1410766d0acf8a20b;hb=b5f5aaabb45923b4964fcf6bdae979fae9d1bfb9;hp=8c6f38832bfc3005773af18777ff8073b43750c3;hpb=b1f57156c63df5b18ade2209c843f902c394d695;p=modules%2Fshaper.git diff --git a/src/PartSet/PartSet_Tools.cpp b/src/PartSet/PartSet_Tools.cpp index 8c6f38832..f7c4ab57f 100644 --- a/src/PartSet/PartSet_Tools.cpp +++ b/src/PartSet/PartSet_Tools.cpp @@ -1,3 +1,5 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D + // File: PartSet_Tools.h // Created: 28 Apr 2014 // Author: Natalia ERMOLAEVA @@ -8,6 +10,8 @@ #include #include #include +#include +#include #include #include @@ -15,6 +19,8 @@ #include #include #include +#include +#include #include #include @@ -22,25 +28,29 @@ #include #include #include +#include +#include +#include +#include #include +#include +#include +#include +#include -#include -#include -#include -#include - -#include -#include -#include - -#include +#include #include #include +#include #include #include #include #include +#include +#include +#include +#include #ifdef _DEBUG #include @@ -69,32 +79,34 @@ gp_Pnt PartSet_Tools::convertClickToPoint(QPoint thePoint, Handle(V3d_View) theV gp_Pnt ConvertedPoint(X, Y, Z); gp_Pnt2d ConvertedPointOnPlane = ProjLib::Project(PlaneOfTheView, ConvertedPoint); - gp_Pnt ResultPoint = ElSLib::Value(ConvertedPointOnPlane.X(), ConvertedPointOnPlane.Y(), PlaneOfTheView); + gp_Pnt ResultPoint = ElSLib::Value(ConvertedPointOnPlane.X(), ConvertedPointOnPlane.Y(), + PlaneOfTheView); return ResultPoint; } void PartSet_Tools::convertTo2D(const gp_Pnt& thePoint, FeaturePtr theSketch, - Handle(V3d_View) theView, double& theX, double& theY) +Handle(V3d_View) theView, + double& theX, double& theY) { if (!theSketch) return; AttributeDoublePtr anAttr; - boost::shared_ptr aData = theSketch->data(); + std::shared_ptr aData = theSketch->data(); - boost::shared_ptr anOrigin = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_ORIGIN)); + std::shared_ptr anOrigin = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::ORIGIN_ID())); - boost::shared_ptr aX = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_DIRX)); - boost::shared_ptr anY = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_DIRY)); + std::shared_ptr aX = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::DIRX_ID())); + std::shared_ptr aNorm = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::NORM_ID())); + std::shared_ptr anY = aNorm->xyz()->cross(aX->xyz()); gp_Pnt anOriginPnt(anOrigin->x(), anOrigin->y(), anOrigin->z()); gp_Vec aVec(anOriginPnt, thePoint); - if (!theView.IsNull()) - { + if (!theView.IsNull()) { V3d_Coordinate XEye, YEye, ZEye, XAt, YAt, ZAt; theView->Eye(XEye, YEye, ZEye); @@ -105,125 +117,123 @@ void PartSet_Tools::convertTo2D(const gp_Pnt& thePoint, FeaturePtr theSketch, gp_Vec anEyeVec(EyePoint, AtPoint); anEyeVec.Normalize(); - boost::shared_ptr aNormal = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_NORM)); + std::shared_ptr aNormal = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::NORM_ID())); gp_Vec aNormalVec(aNormal->x(), aNormal->y(), aNormal->z()); double aDen = anEyeVec * aNormalVec; double aLVec = aDen != 0 ? aVec * aNormalVec / aDen : DBL_MAX; - gp_Vec aDeltaVec = anEyeVec*aLVec; + gp_Vec aDeltaVec = anEyeVec * aLVec; aVec = aVec - aDeltaVec; } theX = aVec.X() * aX->x() + aVec.Y() * aX->y() + aVec.Z() * aX->z(); theY = aVec.X() * anY->x() + aVec.Y() * anY->y() + aVec.Z() * anY->z(); } -void PartSet_Tools::convertTo3D(const double theX, const double theY, - FeaturePtr theSketch, - gp_Pnt& thePoint) +std::shared_ptr PartSet_Tools::convertTo3D(const double theX, const double theY, FeaturePtr theSketch) { - if (!theSketch) - return; + std::shared_ptr aData = theSketch->data(); - boost::shared_ptr aData = theSketch->data(); + std::shared_ptr aC = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::ORIGIN_ID())); + std::shared_ptr aX = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::DIRX_ID())); + std::shared_ptr aNorm = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::NORM_ID())); + std::shared_ptr aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir()))); - boost::shared_ptr aC = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_ORIGIN)); - boost::shared_ptr aX = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_DIRX)); - boost::shared_ptr aY = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_DIRY)); + std::shared_ptr aPnt2d = + std::shared_ptr(new GeomAPI_Pnt2d(theX, theY)); - boost::shared_ptr aSum = aC->pnt()->xyz()->added( - aX->dir()->xyz()->multiplied(theX))->added(aY->dir()->xyz()->multiplied(theY)); - - boost::shared_ptr aPoint = boost::shared_ptr(new GeomAPI_Pnt(aSum)); - thePoint = gp_Pnt(aPoint->x(), aPoint->y(), aPoint->z()); + return aPnt2d->to3D(aC->pnt(), aX->dir(), aY); } -boost::shared_ptr PartSet_Tools::createFeaturePrs(const std::string& theKind, - FeaturePtr theSketch, - FeaturePtr theFeature) +ObjectPtr PartSet_Tools::nearestFeature(QPoint thePoint, Handle_V3d_View theView, + FeaturePtr theSketch, + const QList& theSelected, + const QList& theHighlighted) { - boost::shared_ptr aFeaturePrs; + // firstly it finds the feature in the list of highlight + ObjectPtr aDeltaObject = nearestFeature(thePoint, theView, theSketch, theHighlighted); + if (!aDeltaObject) + // secondly it finds the feature in the list of selected objects + aDeltaObject = nearestFeature(thePoint, theView, theSketch, theSelected); - if (theKind == PartSet_FeaturePointPrs::getKind()) { - aFeaturePrs = boost::shared_ptr(new PartSet_FeaturePointPrs(theSketch)); - } - else if (theKind == PartSet_FeatureLinePrs::getKind()) { - aFeaturePrs = boost::shared_ptr(new PartSet_FeatureLinePrs(theSketch)); - } - else if (theKind == PartSet_FeatureCirclePrs::getKind()) { - aFeaturePrs = boost::shared_ptr(new PartSet_FeatureCirclePrs(theSketch)); - } - else if (theKind == PartSet_FeatureArcPrs::getKind()) { - aFeaturePrs = boost::shared_ptr(new PartSet_FeatureArcPrs(theSketch)); - } - else if (theKind == PartSet_ConstraintLengthPrs::getKind()) { - aFeaturePrs = boost::shared_ptr(new PartSet_ConstraintLengthPrs(theSketch)); - } - else if (theKind == PartSet_ConstraintRadiusPrs::getKind()) { - aFeaturePrs = boost::shared_ptr(new PartSet_ConstraintRadiusPrs(theSketch)); - } - else if (theKind == PartSet_ConstraintDistancePrs::getKind()) { - aFeaturePrs = boost::shared_ptr(new PartSet_ConstraintDistancePrs(theSketch)); - } - - - if (theFeature && aFeaturePrs) - aFeaturePrs->init(theFeature); - - return aFeaturePrs; + return aDeltaObject; } -FeaturePtr PartSet_Tools::nearestFeature(QPoint thePoint, Handle_V3d_View theView, - FeaturePtr theSketch, - const std::list& theFeatures) +ObjectPtr PartSet_Tools::nearestFeature(QPoint thePoint, Handle_V3d_View theView, + FeaturePtr theSketch, + const QList& thePresentations) { - double aX, anY; - gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(thePoint, theView); - PartSet_Tools::convertTo2D(aPoint, theSketch, theView, aX, anY); - - FeaturePtr aFeature; - std::list::const_iterator anIt = theFeatures.begin(), aLast = theFeatures.end(); - - FeaturePtr aDeltaFeature; - double aMinDelta = -1; - XGUI_ViewerPrs aPrs; - for (; anIt != aLast; anIt++) { - aPrs = *anIt; - if (!aPrs.feature()) - continue; - boost::shared_ptr aSketchFeature = - boost::dynamic_pointer_cast(aPrs.feature()); - if (!aSketchFeature) - continue; - double aDelta = aSketchFeature->distanceToPoint( - boost::shared_ptr(new GeomAPI_Pnt2d(aX, anY))); - if (aMinDelta < 0 || aMinDelta > aDelta) { - aMinDelta = aDelta; - aDeltaFeature = aPrs.feature(); + ObjectPtr aDeltaObject; + + CompositeFeaturePtr aSketch = + std::dynamic_pointer_cast(theSketch); + // 1. find it in the selected list by the selected point + if (!aDeltaObject) { + double aX, anY; + gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(thePoint, theView); + PartSet_Tools::convertTo2D(aPoint, theSketch, theView, aX, anY); + + FeaturePtr aFeature; + double aMinDelta = -1; + ModuleBase_ViewerPrs aPrs; + foreach (ModuleBase_ViewerPrs aPrs, thePresentations) { + if (!aPrs.object()) + continue; + FeaturePtr aFeature = ModelAPI_Feature::feature(aPrs.object()); + std::shared_ptr aSketchFeature = std::dynamic_pointer_cast< + SketchPlugin_Feature>(aFeature); + if (!aSketchFeature || !aSketch->isSub(aSketchFeature)) + continue; + + double aDelta = aSketchFeature->distanceToPoint( + std::shared_ptr(new GeomAPI_Pnt2d(aX, anY))); + if (aMinDelta < 0 || aMinDelta > aDelta) { + aMinDelta = aDelta; + // TODO aDeltaObject = aPrs.result(); + } + } + } + // 2. if the object is not found, returns the first selected sketch feature + if (!aDeltaObject && thePresentations.size() > 0) { + // there can be some highlighted objects, e.g. a result of boolean operation and a sketch point + foreach (ModuleBase_ViewerPrs aPrs, thePresentations) { + if (!aPrs.object()) + continue; + FeaturePtr aFeature = ModelAPI_Feature::feature(aPrs.object()); + if (aFeature && aSketch->isSub(aFeature)) + aDeltaObject = aPrs.object(); } } - return aDeltaFeature; + return aDeltaObject; } -boost::shared_ptr PartSet_Tools::document() +std::shared_ptr PartSet_Tools::document() { - return ModelAPI_PluginManager::get()->rootDocument(); + return ModelAPI_Session::get()->moduleDocument(); } -void PartSet_Tools::setFeaturePoint(FeaturePtr theFeature, double theX, double theY, - const std::string& theAttribute) +std::shared_ptr PartSet_Tools::getFeaturePoint(FeaturePtr theFeature, + double theX, double theY) { - if (!theFeature) - return; - boost::shared_ptr aData = theFeature->data(); - boost::shared_ptr aPoint = - boost::dynamic_pointer_cast(aData->attribute(theAttribute)); - if (aPoint) - aPoint->setValue(theX, theY); + std::shared_ptr aClickedPoint = std::shared_ptr( + new GeomAPI_Pnt2d(theX, theY)); + std::list > anAttiributes = + theFeature->data()->attributes(GeomDataAPI_Point2D::type()); + std::list >::const_iterator anIt = anAttiributes.begin(), + aLast = anAttiributes.end(); + std::shared_ptr aFPoint; + for (; anIt != aLast && !aFPoint; anIt++) { + std::shared_ptr aCurPoint = std::dynamic_pointer_cast< + GeomDataAPI_Point2D>(*anIt); + if (aCurPoint && aCurPoint->pnt()->distance(aClickedPoint) < Precision::Confusion()) + aFPoint = aCurPoint; + } + + return aFPoint; } void PartSet_Tools::setFeatureValue(FeaturePtr theFeature, double theValue, @@ -231,9 +241,9 @@ void PartSet_Tools::setFeatureValue(FeaturePtr theFeature, double theValue, { if (!theFeature) return; - boost::shared_ptr aData = theFeature->data(); - AttributeDoublePtr anAttribute = - boost::dynamic_pointer_cast(aData->attribute(theAttribute)); + std::shared_ptr aData = theFeature->data(); + AttributeDoublePtr anAttribute = std::dynamic_pointer_cast( + aData->attribute(theAttribute)); if (anAttribute) anAttribute->setValue(theValue); } @@ -242,11 +252,11 @@ double PartSet_Tools::featureValue(FeaturePtr theFeature, const std::string& the bool& isValid) { isValid = false; - double aValue; + double aValue = 0; if (theFeature) { - boost::shared_ptr aData = theFeature->data(); - AttributeDoublePtr anAttribute = - boost::dynamic_pointer_cast(aData->attribute(theAttribute)); + std::shared_ptr aData = theFeature->data(); + AttributeDoublePtr anAttribute = std::dynamic_pointer_cast( + aData->attribute(theAttribute)); if (anAttribute) { aValue = anAttribute->value(); isValid = true; @@ -262,11 +272,11 @@ FeaturePtr PartSet_Tools::feature(FeaturePtr theFeature, const std::string& theA if (!theFeature) return aFeature; - boost::shared_ptr aData = theFeature->data(); - boost::shared_ptr anAttr = - boost::dynamic_pointer_cast(aData->attribute(theAttribute)); + std::shared_ptr aData = theFeature->data(); + std::shared_ptr anAttr = std::dynamic_pointer_cast< + ModelAPI_AttributeRefAttr>(aData->attribute(theAttribute)); if (anAttr) { - aFeature = anAttr->feature(); + aFeature = std::dynamic_pointer_cast(anAttr->object()); if (!theKind.empty() && aFeature && aFeature->getKind() != theKind) { aFeature = FeaturePtr(); } @@ -274,114 +284,361 @@ FeaturePtr PartSet_Tools::feature(FeaturePtr theFeature, const std::string& theA return aFeature; } -void PartSet_Tools::createConstraint(FeaturePtr theSketch, - boost::shared_ptr thePoint1, - boost::shared_ptr thePoint2) +void PartSet_Tools::createConstraint(CompositeFeaturePtr theSketch, + std::shared_ptr thePoint1, + std::shared_ptr thePoint2) { - boost::shared_ptr aDoc = document(); - FeaturePtr aFeature = aDoc->addFeature(SKETCH_CONSTRAINT_COINCIDENCE_KIND); - + FeaturePtr aFeature; if (theSketch) { - boost::shared_ptr aSketch = - boost::dynamic_pointer_cast(theSketch); - aSketch->addSub(aFeature); + aFeature = theSketch->addFeature(SketchPlugin_ConstraintCoincidence::ID()); + } else { + std::shared_ptr aDoc = document(); + aFeature = aDoc->addFeature(SketchPlugin_ConstraintCoincidence::ID()); } - boost::shared_ptr aData = aFeature->data(); + std::shared_ptr aData = aFeature->data(); - boost::shared_ptr aRef1 = - boost::dynamic_pointer_cast(aData->attribute(CONSTRAINT_ATTR_ENTITY_A)); + std::shared_ptr aRef1 = std::dynamic_pointer_cast< + ModelAPI_AttributeRefAttr>(aData->attribute(SketchPlugin_Constraint::ENTITY_A())); aRef1->setAttr(thePoint1); - boost::shared_ptr aRef2 = - boost::dynamic_pointer_cast(aData->attribute(CONSTRAINT_ATTR_ENTITY_B)); + std::shared_ptr aRef2 = std::dynamic_pointer_cast< + ModelAPI_AttributeRefAttr>(aData->attribute(SketchPlugin_Constraint::ENTITY_B())); aRef2->setAttr(thePoint2); - if (aFeature) // TODO: generate an error if feature was not created + if (aFeature) // TODO: generate an error if feature was not created aFeature->execute(); } -void PartSet_Tools::setConstraints(FeaturePtr theSketch, FeaturePtr theFeature, - const std::string& theAttribute, - double theClickedX, double theClickedY) +std::shared_ptr PartSet_Tools:: + findAttributePoint(CompositeFeaturePtr theSketch, double theX, double theY, + double theTolerance, const QList& theIgnore) +{ + std::shared_ptr aClickedPoint = std::shared_ptr( + new GeomAPI_Pnt2d(theX, theY)); + + std::list > anAttiributes; + for (int i = 0; i < theSketch->numberOfSubs(); i++) { + FeaturePtr aFeature = theSketch->subFeature(i); + if (!theIgnore.contains(aFeature)) { + anAttiributes = aFeature->data()->attributes(GeomDataAPI_Point2D::type()); + + std::list >::const_iterator anIt; + for (anIt = anAttiributes.cbegin(); anIt != anAttiributes.cend(); ++anIt) { + std::shared_ptr aCurPoint = + std::dynamic_pointer_cast(*anIt); + double x = aCurPoint->x(); + double y = aCurPoint->y(); + if (aCurPoint && (aCurPoint->pnt()->distance(aClickedPoint) < theTolerance)) { + return aCurPoint; + } + } + } + } + return std::shared_ptr(); +} + + +void PartSet_Tools::setConstraints(CompositeFeaturePtr theSketch, FeaturePtr theFeature, + const std::string& theAttribute, double theClickedX, + double theClickedY) { // find a feature point by the selection mode - //boost::shared_ptr aPoint = featurePoint(theMode); - boost::shared_ptr aFeaturePoint = - boost::dynamic_pointer_cast(theFeature->data()->attribute(theAttribute)); + //std::shared_ptr aPoint = featurePoint(theMode); + std::shared_ptr aFeaturePoint = std::dynamic_pointer_cast< + GeomDataAPI_Point2D>(theFeature->data()->attribute(theAttribute)); if (!aFeaturePoint) return; // get all sketch features. If the point with the given coordinates belong to any sketch feature, // the constraint is created between the feature point and the found sketch point - boost::shared_ptr aData = theSketch->data(); - boost::shared_ptr aRefList = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_FEATURES)); - - std::list aFeatures = aRefList->list(); - std::list::const_iterator anIt = aFeatures.begin(), aLast = aFeatures.end(); - std::list > anAttiributes; - boost::shared_ptr aClickedPoint = boost::shared_ptr - (new GeomAPI_Pnt2d(theClickedX, theClickedY)); - for (; anIt != aLast; anIt++) - { - FeaturePtr aFeature = *anIt; + std::shared_ptr aData = theSketch->data(); + std::shared_ptr aRefList = std::dynamic_pointer_cast< + ModelAPI_AttributeRefList>(aData->attribute(SketchPlugin_Sketch::FEATURES_ID())); + + std::list aFeatures = aRefList->list(); + std::list::const_iterator anIt = aFeatures.begin(), aLast = aFeatures.end(); + std::list > anAttiributes; + std::shared_ptr aClickedPoint = std::shared_ptr( + new GeomAPI_Pnt2d(theClickedX, theClickedY)); + for (; anIt != aLast; anIt++) { + FeaturePtr aFeature = std::dynamic_pointer_cast(*anIt); + if (theFeature == aFeature) + continue; // find the given point in the feature attributes anAttiributes = aFeature->data()->attributes(GeomDataAPI_Point2D::type()); - std::list >::const_iterator anIt = anAttiributes.begin(), - aLast = anAttiributes.end(); - boost::shared_ptr aFPoint; - for (;anIt!=aLast && !aFPoint; anIt++) { - boost::shared_ptr aCurPoint = - boost::dynamic_pointer_cast(*anIt); - if (aCurPoint && aCurPoint->pnt()->distance(aClickedPoint) < Precision::Confusion()) + std::list >::const_iterator anIt = anAttiributes.begin(), + aLast = anAttiributes.end(); + std::shared_ptr aFPoint; + for (; anIt != aLast && !aFPoint; anIt++) { + std::shared_ptr aCurPoint = + std::dynamic_pointer_cast(*anIt); + if (aCurPoint && (aCurPoint->pnt()->distance(aClickedPoint) < Precision::Confusion())) { aFPoint = aCurPoint; + break; + } } if (aFPoint) PartSet_Tools::createConstraint(theSketch, aFPoint, aFeaturePoint); } } -boost::shared_ptr PartSet_Tools::sketchPlane(FeaturePtr theSketch) +std::shared_ptr PartSet_Tools::sketchPlane(CompositeFeaturePtr theSketch) { - boost::shared_ptr aPlane; - double aA, aB, aC, aD; - - boost::shared_ptr aData = theSketch->data(); - boost::shared_ptr anOrigin = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_ORIGIN)); - boost::shared_ptr aNormal = - boost::dynamic_pointer_cast(aData->attribute(SKETCH_ATTR_NORM)); - aA = aNormal->x(); - aB = aNormal->y(); - aC = aNormal->z(); - aD = 0; - - aPlane = boost::shared_ptr(new GeomAPI_Pln(aA, aB, aC, aD)); + std::shared_ptr aPlane; + + std::shared_ptr aData = theSketch->data(); + if (aData) { + std::shared_ptr anOrigin = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::ORIGIN_ID())); + std::shared_ptr aNormal = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::NORM_ID())); + if (aNormal && anOrigin) { + double adX = aNormal->x(); + double adY = aNormal->y(); + double adZ = aNormal->z(); + + if ( (adX != 0) || (adY != 0) || (adZ != 0) ) { // Plane is valid + double aX = anOrigin->x(); + double aY = anOrigin->y(); + double aZ = anOrigin->z(); + gp_Pln aPln(gp_Pnt(aX, aY, aZ), gp_Dir(adX, adY, adZ)); + double aA, aB, aC, aD; + aPln.Coefficients(aA, aB, aC, aD); + aPlane = std::shared_ptr(new GeomAPI_Pln(aA, aB, aC, aD)); + } + } + } return aPlane; } -boost::shared_ptr PartSet_Tools::point3D( - boost::shared_ptr thePoint2D, - FeaturePtr theSketch) +std::shared_ptr PartSet_Tools::point3D(std::shared_ptr thePoint2D, + CompositeFeaturePtr theSketch) { - boost::shared_ptr aPoint; + std::shared_ptr aPoint; if (!theSketch || !thePoint2D) return aPoint; - boost::shared_ptr aC = - boost::dynamic_pointer_cast(theSketch->data()->attribute(SKETCH_ATTR_ORIGIN)); - boost::shared_ptr aX = - boost::dynamic_pointer_cast(theSketch->data()->attribute(SKETCH_ATTR_DIRX)); - boost::shared_ptr aY = - boost::dynamic_pointer_cast(theSketch->data()->attribute(SKETCH_ATTR_DIRY)); + DataPtr aData = theSketch->data(); + std::shared_ptr aC = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::ORIGIN_ID())); + std::shared_ptr aX = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::DIRX_ID())); + std::shared_ptr aNorm = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::NORM_ID())); + std::shared_ptr aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir()))); - return thePoint2D->to3D(aC->pnt(), aX->dir(), aY->dir()); + return thePoint2D->to3D(aC->pnt(), aX->dir(), aY); } -bool PartSet_Tools::isConstraintFeature(const std::string& theKind) +ResultPtr PartSet_Tools::createFixedObjectByExternal(const TopoDS_Shape& theShape, + const ObjectPtr& theObject, + CompositeFeaturePtr theSketch) { - return theKind == PartSet_ConstraintLengthPrs::getKind() || - theKind == PartSet_ConstraintDistancePrs::getKind() || - theKind == PartSet_ConstraintRadiusPrs::getKind(); + if (theShape.ShapeType() == TopAbs_EDGE) { + // Check that we already have such external edge + std::shared_ptr aInEdge = std::shared_ptr(new GeomAPI_Edge()); + aInEdge->setImpl(new TopoDS_Shape(theShape)); + ResultPtr aResult = findExternalEdge(theSketch, aInEdge); + if (aResult) + return aResult; + + // If not found then we have to create new + Standard_Real aStart, aEnd; + Handle(V3d_View) aNullView; + FeaturePtr aMyFeature; + + Handle(Geom_Curve) aCurve = BRep_Tool::Curve(TopoDS::Edge(theShape), aStart, aEnd); + GeomAdaptor_Curve aAdaptor(aCurve); + if (aAdaptor.GetType() == GeomAbs_Line) { + // Create line + aMyFeature = theSketch->addFeature(SketchPlugin_Line::ID()); + } else if (aAdaptor.GetType() == GeomAbs_Circle) { + if (aAdaptor.IsClosed()) { + // Create circle + aMyFeature = theSketch->addFeature(SketchPlugin_Circle::ID()); + } else { + // Create arc + aMyFeature = theSketch->addFeature(SketchPlugin_Arc::ID()); + } + } + if (aMyFeature) { + DataPtr aData = aMyFeature->data(); + AttributeSelectionPtr anAttr = + std::dynamic_pointer_cast + (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID())); + + ResultPtr aRes = std::dynamic_pointer_cast(theObject); + if (anAttr && aRes) { + std::shared_ptr anEdge(new GeomAPI_Shape); + anEdge->setImpl(new TopoDS_Shape(theShape)); + + anAttr->setValue(aRes, anEdge); + + aMyFeature->execute(); + + // fix this edge + FeaturePtr aFix = theSketch->addFeature(SketchPlugin_ConstraintRigid::ID()); + aFix->data()->refattr(SketchPlugin_Constraint::ENTITY_A())-> + setObject(aMyFeature->lastResult()); + + return aMyFeature->lastResult(); + } + } + } + if (theShape.ShapeType() == TopAbs_VERTEX) { + std::shared_ptr aInVert = std::shared_ptr(new GeomAPI_Vertex()); + aInVert->setImpl(new TopoDS_Shape(theShape)); + ResultPtr aResult = findExternalVertex(theSketch, aInVert); + if (aResult) + return aResult; + + FeaturePtr aMyFeature = theSketch->addFeature(SketchPlugin_Point::ID()); + + if (aMyFeature) { + DataPtr aData = aMyFeature->data(); + AttributeSelectionPtr anAttr = + std::dynamic_pointer_cast + (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID())); + + ResultPtr aRes = std::dynamic_pointer_cast(theObject); + if (anAttr && aRes) { + std::shared_ptr aVert(new GeomAPI_Shape); + aVert->setImpl(new TopoDS_Shape(theShape)); + + anAttr->setValue(aRes, aVert); + aMyFeature->execute(); + + // fix this edge + FeaturePtr aFix = theSketch->addFeature(SketchPlugin_ConstraintRigid::ID()); + aFix->data()->refattr(SketchPlugin_Constraint::ENTITY_A())-> + setObject(aMyFeature->lastResult()); + + return aMyFeature->lastResult(); + } + } + } + return ResultPtr(); +} + +bool PartSet_Tools::isContainPresentation(const QList& theSelected, + const ModuleBase_ViewerPrs& thePrs) +{ + foreach (ModuleBase_ViewerPrs aPrs, theSelected) { + if (aPrs.object() == thePrs.object()) + return true; + } + return false; +} + +ResultPtr PartSet_Tools::findExternalEdge(CompositeFeaturePtr theSketch, std::shared_ptr theEdge) +{ + for (int i = 0; i < theSketch->numberOfSubs(); i++) { + FeaturePtr aFeature = theSketch->subFeature(i); + std::shared_ptr aSketchFea = + std::dynamic_pointer_cast(aFeature); + if (aSketchFea) { + if (aSketchFea->isExternal()) { + std::list aResults = aSketchFea->results(); + std::list::const_iterator aIt; + for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) { + ResultConstructionPtr aRes = + std::dynamic_pointer_cast(*aIt); + if (aRes) { + std::shared_ptr aShape = aRes->shape(); + if (aShape) { + if (theEdge->isEqual(aShape)) + return aRes; + } + } + } + } + } + } + return ResultPtr(); +} + + +ResultPtr PartSet_Tools::findExternalVertex(CompositeFeaturePtr theSketch, std::shared_ptr theVert) +{ + for (int i = 0; i < theSketch->numberOfSubs(); i++) { + FeaturePtr aFeature = theSketch->subFeature(i); + std::shared_ptr aSketchFea = + std::dynamic_pointer_cast(aFeature); + if (aSketchFea) { + if (aSketchFea->isExternal()) { + std::list aResults = aSketchFea->results(); + std::list::const_iterator aIt; + for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) { + ResultConstructionPtr aRes = + std::dynamic_pointer_cast(*aIt); + if (aRes) { + std::shared_ptr aShape = aRes->shape(); + if (aShape) { + if (theVert->isEqual(aShape)) + return aRes; + } + } + } + } + } + } + return ResultPtr(); +} + + +bool PartSet_Tools::hasVertexShape(const ModuleBase_ViewerPrs& thePrs, FeaturePtr theSketch, + Handle_V3d_View theView, double& theX, double& theY) +{ + bool aHasVertex = false; + + const TopoDS_Shape& aShape = thePrs.shape(); + if (!aShape.IsNull() && aShape.ShapeType() == TopAbs_VERTEX) + { + const TopoDS_Vertex& aVertex = TopoDS::Vertex(aShape); + if (!aVertex.IsNull()) + { + gp_Pnt aPoint = BRep_Tool::Pnt(aVertex); + PartSet_Tools::convertTo2D(aPoint, theSketch, theView, theX, theY); + aHasVertex = true; + } + } + + return aHasVertex; +} + +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 aValue = std::shared_ptr( + new GeomAPI_Pnt(aPoint.X(), aPoint.Y(), aPoint.Z())); + + // find the given point in the feature attributes + std::list anAttiributes = + aFeature->data()->attributes(GeomDataAPI_Point2D::type()); + std::list::const_iterator anIt = anAttiributes.begin(), + aLast = anAttiributes.end(); + for (; anIt != aLast && !anAttribute; anIt++) { + std::shared_ptr aCurPoint = + std::dynamic_pointer_cast(*anIt); + + std::shared_ptr aPnt = convertTo3D(aCurPoint->x(), aCurPoint->y(), theSketch); + if (aPnt && (aPnt->distance(aValue) < Precision::Confusion())) { + anAttribute = aCurPoint; + break; + } + } + } + } + } + return anAttribute; }