X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_Tools.cpp;h=2b5315a8fbcd79168330f5626f9eb962a44b3028;hb=75a52b87325dd36217603277b84bab5fa345b642;hp=b488201750a4866ff82aa1ff3d150af14b2a2223;hpb=ec9614e2a90b00b9ed8f453ce7d2ca8e1a53f78b;p=modules%2Fshaper.git diff --git a/src/PartSet/PartSet_Tools.cpp b/src/PartSet/PartSet_Tools.cpp old mode 100644 new mode 100755 index b48820175..2b5315a8f --- a/src/PartSet/PartSet_Tools.cpp +++ b/src/PartSet/PartSet_Tools.cpp @@ -1,10 +1,26 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: PartSet_Tools.h -// Created: 28 Apr 2014 -// Author: Natalia ERMOLAEVA +// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or +// email : webmaster.salome@opencascade.com +// #include +#include +#include #include #include @@ -12,6 +28,23 @@ #include #include #include +#include +#include +#include + +#include + +#include + +#include + +#include + +#include +#include +#include +#include +#include #include #include @@ -38,7 +71,9 @@ #include #include +#include #include +#include #include #include @@ -51,12 +86,23 @@ #include #include #include +#include +#include +#include + +#include #ifdef _DEBUG #include #endif const double PRECISION_TOLERANCE = 0.000001; +const int AIS_DEFAULT_WIDTH = 2; + +int PartSet_Tools::getAISDefaultWidth() +{ + return AIS_DEFAULT_WIDTH; +} gp_Pnt PartSet_Tools::convertClickToPoint(QPoint thePoint, Handle(V3d_View) theView) { @@ -131,7 +177,25 @@ Handle(V3d_View) theView, theY = aVec.X() * anY->x() + aVec.Y() * anY->y() + aVec.Z() * anY->z(); } -std::shared_ptr PartSet_Tools::convertTo3D(const double theX, const double theY, FeaturePtr theSketch) +std::shared_ptr PartSet_Tools::convertTo2D(FeaturePtr theSketch, + const std::shared_ptr& thePnt) +{ + std::shared_ptr aRes; + if (theSketch->getKind() != SketchPlugin_Sketch::ID()) + return aRes; + std::shared_ptr aC = std::dynamic_pointer_cast( + theSketch->data()->attribute(SketchPlugin_Sketch::ORIGIN_ID())); + std::shared_ptr aNorm = std::dynamic_pointer_cast( + theSketch->data()->attribute(SketchPlugin_Sketch::NORM_ID())); + std::shared_ptr aX = std::dynamic_pointer_cast( + theSketch->data()->attribute(SketchPlugin_Sketch::DIRX_ID())); + std::shared_ptr aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir()))); + return thePnt->to2D(aC->pnt(), aX->dir(), aY); +} + + +std::shared_ptr PartSet_Tools::convertTo3D(const double theX, const double theY, + FeaturePtr theSketch) { std::shared_ptr aData = theSketch->data(); @@ -143,99 +207,17 @@ std::shared_ptr PartSet_Tools::convertTo3D(const double theX, const aData->attribute(SketchPlugin_Sketch::NORM_ID())); std::shared_ptr aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir()))); - std::shared_ptr aPnt2d = + std::shared_ptr aPnt2d = std::shared_ptr(new GeomAPI_Pnt2d(theX, theY)); return aPnt2d->to3D(aC->pnt(), aX->dir(), aY); } -ObjectPtr PartSet_Tools::nearestFeature(QPoint thePoint, Handle_V3d_View theView, - FeaturePtr theSketch, - const QList& theSelected, - const QList& theHighlighted) -{ - // 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); - - return aDeltaObject; -} - -ObjectPtr PartSet_Tools::nearestFeature(QPoint thePoint, Handle_V3d_View theView, - FeaturePtr theSketch, - const QList& thePresentations) -{ - 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 aDeltaObject; -} - std::shared_ptr PartSet_Tools::document() { return ModelAPI_Session::get()->moduleDocument(); } -std::shared_ptr PartSet_Tools::getFeaturePoint(FeaturePtr theFeature, - double theX, double theY) -{ - std::shared_ptr aClickedPoint = std::shared_ptr( - new GeomAPI_Pnt2d(theX, theY)); - std::list > anAttiributes = - theFeature->data()->attributes(GeomDataAPI_Point2D::typeId()); - 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, const std::string& theAttribute) { @@ -306,109 +288,23 @@ void PartSet_Tools::createConstraint(CompositeFeaturePtr theSketch, ModelAPI_AttributeRefAttr>(aData->attribute(SketchPlugin_Constraint::ENTITY_B())); aRef2->setAttr(thePoint2); - if (aFeature) // TODO: generate an error if feature was not created - aFeature->execute(); -} - -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::typeId()); - - 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 - //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 - 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::typeId()); - 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); - } + // we need to flush created signal in order to coincidence is processed by solver + Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED)); } std::shared_ptr PartSet_Tools::sketchPlane(CompositeFeaturePtr theSketch) { 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)); - } - } - } + std::shared_ptr anOrigin = std::dynamic_pointer_cast( + theSketch->data()->attribute(SketchPlugin_Sketch::ORIGIN_ID())); + std::shared_ptr aNormal = std::dynamic_pointer_cast( + theSketch->data()->attribute(SketchPlugin_Sketch::NORM_ID())); + + if (aNormal.get() && aNormal->isInitialized() && + anOrigin.get() && anOrigin->isInitialized()) + aPlane = std::shared_ptr(new GeomAPI_Pln(anOrigin->pnt(), aNormal->dir())); + return aPlane; } @@ -450,9 +346,10 @@ ResultPtr PartSet_Tools::findFixedObjectByExternal(const TopoDS_Shape& theShape, return aResult; } -ResultPtr PartSet_Tools::createFixedObjectByExternal(const TopoDS_Shape& theShape, - const ObjectPtr& theObject, - CompositeFeaturePtr theSketch) +ResultPtr PartSet_Tools::createFixedObjectByExternal(const TopoDS_Shape& theShape, + const ObjectPtr& theObject, + CompositeFeaturePtr theSketch, + const bool theTemporary) { if (theShape.ShapeType() == TopAbs_EDGE) { Standard_Real aStart, aEnd; @@ -461,15 +358,51 @@ ResultPtr PartSet_Tools::createFixedObjectByExternal(const TopoDS_Shape& theShap Handle(Geom_Curve) aCurve = BRep_Tool::Curve(TopoDS::Edge(theShape), aStart, aEnd); GeomAdaptor_Curve aAdaptor(aCurve); + std::shared_ptr anEdge = std::shared_ptr(new GeomAPI_Edge); + anEdge->setImpl(new TopoDS_Shape(theShape)); if (aAdaptor.GetType() == GeomAbs_Line) { // Create line aMyFeature = theSketch->addFeature(SketchPlugin_Line::ID()); + if (!theObject.get()) { + // There is no selected result + std::shared_ptr aPnt1 = anEdge->firstPoint(); + std::shared_ptr aPnt2 = anEdge->lastPoint(); + std::shared_ptr aPnt2d1 = convertTo2D(theSketch, aPnt1); + std::shared_ptr aPnt2d2 = convertTo2D(theSketch, aPnt2); + + std::shared_ptr aData = aMyFeature->data(); + std::shared_ptr aPoint1 = + std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Line::START_ID())); + std::shared_ptr aPoint2 = + std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Line::END_ID())); + + aPoint1->setValue(aPnt2d1); + aPoint2->setValue(aPnt2d2); + + // If this is an axis then its name has to be changed correspondently + std::string aSuffix = ""; + bool aXdir = fabs(aPnt1->x() - aPnt2->x()) > Precision::Confusion(); + bool aYdir = fabs(aPnt1->y() - aPnt2->y()) > Precision::Confusion(); + bool aZdir = fabs(aPnt1->z() - aPnt2->z()) > Precision::Confusion(); + if (aXdir && (!aYdir) && (!aZdir)) + aSuffix = "X"; + else if ((!aXdir) && aYdir && (!aZdir)) + aSuffix = "Y"; + else if ((!aXdir) && (!aYdir) && aZdir) + aSuffix = "Z"; + if (aSuffix.length() > 0) + aData->setName("Axis_" + aSuffix); + aMyFeature->execute(); + + } } else if (aAdaptor.GetType() == GeomAbs_Circle) { - std::shared_ptr anEdge = std::shared_ptr(new GeomAPI_Edge); - anEdge->setImpl(new TopoDS_Shape(theShape)); if (anEdge->isArc()) { // Create arc aMyFeature = theSketch->addFeature(SketchPlugin_Arc::ID()); + if (theShape.Orientation() == TopAbs_REVERSED) + aMyFeature->boolean(SketchPlugin_Arc::REVERSED_ID())->setValue(true); } else { // Create circle @@ -478,24 +411,55 @@ ResultPtr PartSet_Tools::createFixedObjectByExternal(const TopoDS_Shape& theShap } if (aMyFeature) { DataPtr aData = aMyFeature->data(); - AttributeSelectionPtr anAttr = + AttributeSelectionPtr anAttr = std::dynamic_pointer_cast (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID())); ResultPtr aRes = std::dynamic_pointer_cast(theObject); - if (anAttr && aRes) { + // selection shape has no result owner => the trihedron axis + // TODO: make reference to the real axes when + // they are implemented in the initialization plugin + if (!aRes.get()) { + ObjectPtr aPointObj = ModelAPI_Session::get()->moduleDocument()->objectByName( + ModelAPI_ResultConstruction::group(), "Origin"); + if (aPointObj.get()) { // if initialization plugin performed well + aRes = std::dynamic_pointer_cast(aPointObj); + } + } + if (!aRes.get()) { + aRes = aMyFeature->firstResult(); + } + if (anAttr.get() && aRes.get()) { std::shared_ptr anEdge(new GeomAPI_Shape); anEdge->setImpl(new TopoDS_Shape(theShape)); anAttr->setValue(aRes, anEdge); + //if (!theTemporary) { + aMyFeature->execute(); + + // issue #2125: Naming problem: two edges in Naming for one circle on solid + // this is result of boolean and seamedge + if (aAdaptor.GetType() == GeomAbs_Circle) { + ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); + if (!aFactory->validate(aMyFeature)) { + anAttr->setValue(ResultPtr(), GeomShapePtr()); + std::set aFeatures; + aFeatures.insert(aMyFeature); + ModelAPI_Tools::removeFeaturesAndReferences(aFeatures); + Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED)); + Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED)); + + return ResultPtr(); + } + } - aMyFeature->execute(); - - // fix this edge - FeaturePtr aFix = theSketch->addFeature(SketchPlugin_ConstraintRigid::ID()); - aFix->data()->refattr(SketchPlugin_Constraint::ENTITY_A())-> - setObject(aMyFeature->lastResult()); - + // // fix this edge + // FeaturePtr aFix = theSketch->addFeature(SketchPlugin_ConstraintRigid::ID()); + // aFix->data()->refattr(SketchPlugin_Constraint::ENTITY_A())-> + // setObject(aMyFeature->lastResult()); + // // we need to flush created signal in order to fixed constraint is processed by solver + // Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED)); + //} return aMyFeature->lastResult(); } } @@ -505,23 +469,59 @@ ResultPtr PartSet_Tools::createFixedObjectByExternal(const TopoDS_Shape& theShap if (aMyFeature) { DataPtr aData = aMyFeature->data(); - AttributeSelectionPtr anAttr = + AttributeSelectionPtr anAttr = std::dynamic_pointer_cast (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID())); ResultPtr aRes = std::dynamic_pointer_cast(theObject); - if (anAttr && aRes) { + // if there is no object, + // it means that this is the origin point: search it in the module document + if (!aRes.get()) { + ObjectPtr aPointObj = ModelAPI_Session::get()->moduleDocument()->objectByName( + ModelAPI_ResultConstruction::group(), "Origin"); + if (aPointObj.get()) { // if initialization plugin performed well + aRes = std::dynamic_pointer_cast(aPointObj); + } + } + // reference to itself with name "Origin" (but this may cause the infinitive cycling) + if (!aRes.get()) { + // If the point is selected not from Result object + std::shared_ptr aShape = + std::shared_ptr(new GeomAPI_Shape()); + aShape->setImpl(new TopoDS_Shape(theShape)); + + std::shared_ptr aVertex = + std::shared_ptr(new GeomAPI_Vertex(aShape)); + std::shared_ptr aPnt = aVertex->point(); + + std::shared_ptr aPnt2d = convertTo2D(theSketch, aPnt); + std::shared_ptr aPoint = + std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Point::COORD_ID())); + aPoint->setValue(aPnt2d); + if ((aPnt->x() < Precision::Confusion()) && + (aPnt->y() < Precision::Confusion()) && + (aPnt->z() < Precision::Confusion())) + aData->setName("Origin"); + + aMyFeature->execute(); + aRes = aMyFeature->firstResult(); + } + if (anAttr.get() && aRes.get()) { 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()); - + //if (theTemporary) { + aMyFeature->execute(); + + // // fix this edge + // FeaturePtr aFix = theSketch->addFeature(SketchPlugin_ConstraintRigid::ID()); + // aFix->data()->refattr(SketchPlugin_Constraint::ENTITY_A())-> + // setObject(aMyFeature->lastResult()); + // // we need to flush created signal in order to fixed constraint is processed by solver + // Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED)); + //} return aMyFeature->lastResult(); } } @@ -529,28 +529,30 @@ ResultPtr PartSet_Tools::createFixedObjectByExternal(const TopoDS_Shape& theShap return ResultPtr(); } -bool PartSet_Tools::isContainPresentation(const QList& theSelected, - const ModuleBase_ViewerPrs& thePrs) +bool PartSet_Tools::isContainPresentation(const QList& theSelected, + const ModuleBase_ViewerPrsPtr& thePrs) { - foreach (ModuleBase_ViewerPrs aPrs, theSelected) { - if (aPrs.object() == thePrs.object()) + foreach (ModuleBase_ViewerPrsPtr aPrs, theSelected) { + if (aPrs->object() == thePrs->object()) return true; } return false; } -ResultPtr PartSet_Tools::findExternalEdge(CompositeFeaturePtr theSketch, std::shared_ptr theEdge) +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::shared_ptr aSketchFea = std::dynamic_pointer_cast(aFeature); - if (aSketchFea) { + // not displayed result of feature projection should not be returned as external edge + if (aSketchFea && aSketchFea->canBeDisplayed()) { if (aSketchFea->isExternal()) { std::list aResults = aSketchFea->results(); std::list::const_iterator aIt; for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) { - ResultConstructionPtr aRes = + ResultConstructionPtr aRes = std::dynamic_pointer_cast(*aIt); if (aRes) { std::shared_ptr aShape = aRes->shape(); @@ -567,18 +569,19 @@ ResultPtr PartSet_Tools::findExternalEdge(CompositeFeaturePtr theSketch, std::sh } -ResultPtr PartSet_Tools::findExternalVertex(CompositeFeaturePtr theSketch, std::shared_ptr theVert) +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::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 = + ResultConstructionPtr aRes = std::dynamic_pointer_cast(*aIt); if (aRes) { std::shared_ptr aShape = aRes->shape(); @@ -595,15 +598,16 @@ ResultPtr PartSet_Tools::findExternalVertex(CompositeFeaturePtr theSketch, std:: } -bool PartSet_Tools::hasVertexShape(const ModuleBase_ViewerPrs& thePrs, FeaturePtr theSketch, - Handle_V3d_View theView, double& theX, double& theY) +bool PartSet_Tools::hasVertexShape(const ModuleBase_ViewerPrsPtr& 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 GeomShapePtr& aShape = thePrs->shape(); + if (aShape.get() && !aShape->isNull() && aShape->shapeType() == GeomAPI_Shape::VERTEX) { - const TopoDS_Vertex& aVertex = TopoDS::Vertex(aShape); + const TopoDS_Shape& aTDShape = aShape->impl(); + const TopoDS_Vertex& aVertex = TopoDS::Vertex(aTDShape); if (!aVertex.IsNull()) { gp_Pnt aPoint = BRep_Tool::Pnt(aVertex); @@ -615,8 +619,226 @@ bool PartSet_Tools::hasVertexShape(const ModuleBase_ViewerPrs& thePrs, FeaturePt return aHasVertex; } -AttributePtr PartSet_Tools::findAttributeBy2dPoint(ObjectPtr theObj, - const TopoDS_Shape theShape, +GeomShapePtr PartSet_Tools::findShapeBy2DPoint(const AttributePtr& theAttribute, + ModuleBase_IWorkshop* theWorkshop) +{ + GeomShapePtr aShape; + XGUI_ModuleConnector* aConnector = dynamic_cast(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& aResList = anAttributeFeature->results(); + std::list::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(); + // 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(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(new GeomAPI_Shape); + aShape->setImpl(new TopoDS_Shape(aBRepShape)); + break; + } + } + } + } + } + } + } + return aShape; +} + +std::shared_ptr PartSet_Tools::getPoint( + std::shared_ptr& theFeature, + const std::string& theAttribute) +{ + std::shared_ptr 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(); +} + +std::shared_ptr 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(new GeomAPI_Pnt2d(aX, anY)); +} + +FeaturePtr findFirstCoincidenceByData(const DataPtr& theData, + std::shared_ptr thePoint) +{ + FeaturePtr aCoincident; + + const std::set& aRefsList = theData->refsToMe(); + std::set::const_iterator aIt; + for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) { + std::shared_ptr aAttr = (*aIt); + FeaturePtr aConstrFeature = std::dynamic_pointer_cast(aAttr->owner()); + if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { + std::shared_ptr 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 thePoint) +{ + FeaturePtr aCoincident; + if (theFeature.get() == NULL) + return aCoincident; + + const std::set& aRefsList = theFeature->data()->refsToMe(); + std::set::const_iterator aIt; + for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) { + std::shared_ptr aAttr = (*aIt); + FeaturePtr aConstrFeature = std::dynamic_pointer_cast(aAttr->owner()); + if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { + std::shared_ptr 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 aResults = theFeature->results(); + std::list::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& theList, + QList& theCoincidencies, + std::string theAttr, QList& theIsAttributes) +{ + std::shared_ptr 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(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& aRefsList = aFeature->data()->refsToMe(); + std::set::const_iterator aIt; + for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) { + std::shared_ptr aAttr = (*aIt); + FeaturePtr aConstrFeature = std::dynamic_pointer_cast(aAttr->owner()); + if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { + if (!theCoincidencies.contains(aConstrFeature)) { + std::shared_ptr 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(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& aRefsList = aResult->data()->refsToMe(); + std::set::const_iterator aIt; + for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) { + std::shared_ptr aAttr = (*aIt); + FeaturePtr aConstrFeature = std::dynamic_pointer_cast(aAttr->owner()); + if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { + if (!theCoincidencies.contains(aConstrFeature)) { + std::shared_ptr 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 PartSet_Tools::getCoincedencePoint(FeaturePtr theStartCoin) +{ + std::shared_ptr 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) { @@ -631,15 +853,18 @@ AttributePtr PartSet_Tools::findAttributeBy2dPoint(ObjectPtr theObj, new GeomAPI_Pnt(aPoint.X(), aPoint.Y(), aPoint.Z())); // find the given point in the feature attributes - std::list anAttiributes = + std::list anAttiributes = aFeature->data()->attributes(GeomDataAPI_Point2D::typeId()); - std::list::const_iterator anIt = anAttiributes.begin(), + std::list::const_iterator anIt = anAttiributes.begin(), aLast = anAttiributes.end(); for (; anIt != aLast && !anAttribute; anIt++) { - std::shared_ptr aCurPoint = + std::shared_ptr aCurPoint = std::dynamic_pointer_cast(*anIt); + if (!aCurPoint->isInitialized()) + continue; - std::shared_ptr aPnt = convertTo3D(aCurPoint->x(), aCurPoint->y(), theSketch); + std::shared_ptr aPnt = + convertTo3D(aCurPoint->x(), aCurPoint->y(), theSketch); if (aPnt && (aPnt->distance(aValue) < Precision::Confusion())) { anAttribute = aCurPoint; break; @@ -650,3 +875,33 @@ AttributePtr PartSet_Tools::findAttributeBy2dPoint(ObjectPtr theObj, } return anAttribute; } + +void PartSet_Tools::sendSubFeaturesEvent(const CompositeFeaturePtr& theComposite, + const Events_ID theEventId) +{ + if (!theComposite.get()) + return; + + static Events_Loop* aLoop = Events_Loop::loop(); + for (int i = 0; i < theComposite->numberOfSubs(); i++) { + FeaturePtr aSubFeature = theComposite->subFeature(i); + static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get(); + aECreator->sendUpdated(aSubFeature, theEventId); + } + Events_Loop::loop()->flush(theEventId); +} + +bool PartSet_Tools::isAuxiliarySketchEntity(const ObjectPtr& theObject) +{ + bool isAuxiliaryFeature = false; + + FeaturePtr anObjectFeature = ModelAPI_Feature::feature(theObject); + std::string anAuxiliaryAttribute = SketchPlugin_SketchEntity::AUXILIARY_ID(); + AttributeBooleanPtr anAuxiliaryAttr = std::dynamic_pointer_cast( + anObjectFeature->data()->attribute(anAuxiliaryAttribute)); + if (anAuxiliaryAttr.get()) + isAuxiliaryFeature = anAuxiliaryAttr->value(); + + + return isAuxiliaryFeature; +}