X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketcherPrs%2FSketcherPrs_PositionMgr.cpp;h=1581533d32eafeeb7e13ecbf1ec8241729dacbd1;hb=745c72679f6346375d5e886b25cc3865f3c4daae;hp=1dbe75116261420c424b26c43335b1889d0f8551;hpb=1ded0e810dc406dc9bc3abe7f470d06f0d74ff0e;p=modules%2Fshaper.git diff --git a/src/SketcherPrs/SketcherPrs_PositionMgr.cpp b/src/SketcherPrs/SketcherPrs_PositionMgr.cpp index 1dbe75116..1581533d3 100644 --- a/src/SketcherPrs/SketcherPrs_PositionMgr.cpp +++ b/src/SketcherPrs/SketcherPrs_PositionMgr.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// Copyright (C) 2014-2021 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 @@ -12,26 +12,44 @@ // // 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 +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// See http://www.salome-platform.org/ or -// email : webmaster.salome@opencascade.com +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // #include "SketcherPrs_PositionMgr.h" #include "SketcherPrs_Tools.h" -#include +#include +#include #include -#include +#include +#include #include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include -#include #include #include +#include +#include +#include + +#include static SketcherPrs_PositionMgr* MyPosMgr = NULL; +#define PI 3.1415926535897932 + // The class is implemented as a singlton SketcherPrs_PositionMgr* SketcherPrs_PositionMgr::get() { @@ -44,7 +62,6 @@ SketcherPrs_PositionMgr::SketcherPrs_PositionMgr() { } - int SketcherPrs_PositionMgr::getPositionIndex(ObjectPtr theLine, const SketcherPrs_SymbolPrs* thePrs) { @@ -70,37 +87,141 @@ int SketcherPrs_PositionMgr::getPositionIndex(ObjectPtr theLine, } +bool SketcherPrs_PositionMgr::isPntConstraint(const std::string& theName) +{ + return ((theName == SketchPlugin_ConstraintTangent::ID()) || + (theName == SketchPlugin_ConstraintPerpendicular::ID())); +} + +bool containsPoint(const FeaturePtr& theFeature, GeomPnt2dPtr thePnt2d, GeomPointPtr thePos) +{ + if (theFeature->getKind() == SketchPlugin_Line::ID()) { + AttributePoint2DPtr aSPnt1 = std::dynamic_pointer_cast( + theFeature->data()->attribute(SketchPlugin_Line::START_ID())); + AttributePoint2DPtr aSPnt2 = std::dynamic_pointer_cast( + theFeature->data()->attribute(SketchPlugin_Line::END_ID())); + + GeomPnt2dPtr aPnt1 = aSPnt1->pnt(); + GeomPnt2dPtr aPnt2 = aSPnt2->pnt(); + + if (aPnt1->isEqual(thePnt2d) || aPnt2->isEqual(thePnt2d)) + return true; + } else if ((theFeature->getKind() == SketchPlugin_Circle::ID()) || + (theFeature->getKind() == SketchPlugin_Arc::ID())) { + GeomCurvePtr aCurve; + ObjectPtr aResObj; + std::list aResults = theFeature->results(); + std::list::const_iterator aIt; + for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) { + GeomShapePtr aShp = SketcherPrs_Tools::getShape((*aIt)); + if (aShp->isEdge()) { + aResObj = (*aIt); + aCurve = std::shared_ptr(new GeomAPI_Curve(aShp)); + break; + } + } + if (aCurve.get()) { + double aStart = aCurve->startParam(); + double aEnd = aCurve->endParam(); + GeomCirclePtr aCircle = GeomCirclePtr(new GeomAPI_Circ(aCurve)); + double aParam; + if (aCircle->parameter(thePos, 1.e-4, aParam) && (aParam >= aStart) && (aParam <= aEnd)) + return true; + } + } + return false; +} + +const std::array& SketcherPrs_PositionMgr::getPositionIndex(GeomPointPtr thePos, + const SketcherPrs_SymbolPrs* thePrs) +{ + if (myPntShapes.count(thePrs->feature()) == 0) { + // Renumerate positions around the specified constraint point for all constraints + GeomAx3Ptr aAx3 = thePrs->plane(); + ModelAPI_CompositeFeature* aOwner = thePrs->sketcher(); + GeomPnt2dPtr aPnt2d = thePos->to2D(aAx3->origin(), aAx3->dirX(), aAx3->dirY()); + + int aNbSubs = aOwner->numberOfSubs(); + int aId = 0; + std::list aFeaList; + for (int i = 0; i < aNbSubs; i++) { + FeaturePtr aFeature = aOwner->subFeature(i); + + bool aUseFeature = ((myPntShapes.count(aFeature.get()) == 1) || + (isPntConstraint(aFeature->getKind()))); + if (aUseFeature) { + DataPtr aData = aFeature->data(); + AttributeRefAttrPtr aObjRef = aData->refattr(SketchPlugin_Constraint::ENTITY_A()); + FeaturePtr aObj; + if (aObjRef) + aObj = ModelAPI_Feature::feature(aObjRef->object()); + bool aContains = false; + if (aObj && containsPoint(aObj, aPnt2d, thePos)) { + aContains = true; + } else { + aObjRef = aData->refattr(SketchPlugin_Constraint::ENTITY_B()); + if (aObjRef) + aObj = ModelAPI_Feature::feature(aObjRef->object()); + if (aObj && containsPoint(aObj, aPnt2d, thePos)) { + aContains = true; + } + } + if (aContains) { + myPntShapes[aFeature.get()][0] = aId; + aId++; + aFeaList.push_back(aFeature.get()); + } + } + } + int aSize = (int) aFeaList.size(); + std::list::const_iterator aIt; + for (aIt = aFeaList.cbegin(); aIt != aFeaList.cend(); aIt++) { + myPntShapes[*aIt][1] = aSize; + } + } + return myPntShapes[thePrs->feature()]; +} + +//***************************************************************** gp_Vec getVector(ObjectPtr theShape, GeomDirPtr theDir, gp_Pnt theP) { gp_Vec aVec; std::shared_ptr aShape = SketcherPrs_Tools::getShape(theShape); if (aShape->isEdge()) { + std::shared_ptr anEdge = aShape->edge(); std::shared_ptr aCurve = std::shared_ptr(new GeomAPI_Curve(aShape)); - if (aCurve->isCircle()) { - GeomEdgePtr aEdgePtr(new GeomAPI_Edge(aShape)); - GeomVertexPtr aVertexPtr(new GeomAPI_Vertex(theP.X(), theP.Y(), theP.Z())); - BRepExtrema_ExtPC aExtrema(aVertexPtr->impl(), - aEdgePtr->impl()); - int aNb = aExtrema.NbExt(); - if (aNb > 0) { - for (int i = 1; i <= aNb; i++) { - if (aExtrema.IsMin(i)) { - double aParam = aExtrema.Parameter(i); - Handle(Geom_Curve) aCurv = aCurve->impl(); - gp_Pnt aP; - aCurv->D1(aParam, aP, aVec); - break; - } - } + if (anEdge->isClosed()) { + double aPeriod = aCurve->endParam() - aCurve->startParam(); + Handle(Geom_Curve) aCurv = aCurve->impl(); + GeomAPI_ProjectPointOnCurve anExtr(theP, aCurv); + double aParam = anExtr.LowerDistanceParameter(); + gp_Pnt aP; + aCurv->D1(aParam, aP, aVec); + // 2458: check correct orientation of the vector + if (aVec.SquareMagnitude() > Precision::Confusion()) { + std::shared_ptr aCircEdge(new GeomAPI_Edge(aShape)); + double aFirstParam, aLastParam; + aCircEdge->getRange(aFirstParam, aLastParam); + // if parameter is near the LastParam, make the vector go inside (reverse) + double aDelta = aLastParam - aParam; + while (aDelta < -Precision::Confusion()) + aDelta += aPeriod; + while (aDelta > aPeriod + Precision::Confusion()) + aDelta -= aPeriod; + if (fabs(aDelta) < Precision::Confusion()) + aVec.Reverse(); } } else { - double aMidParam = (aCurve->startParam() + aCurve->endParam()) / 2.; - GeomPointPtr aPnt1 = aCurve->getPoint((aMidParam + aCurve->endParam()) / 2.); - GeomPointPtr aPnt2 = aCurve->getPoint((aMidParam + aCurve->startParam()) / 2.); + GeomPointPtr aPnt1 = aCurve->getPoint(aCurve->endParam()); + GeomPointPtr aPnt2 = aCurve->getPoint(aCurve->startParam()); - aVec = gp_Vec(aPnt1->impl(), aPnt2->impl()); + gp_Pnt aPn2 = aPnt2->impl(); + if (aPn2.IsEqual(theP, Precision::Confusion())) + aVec = gp_Vec(aPn2, aPnt1->impl()); + else + aVec = gp_Vec(aPnt1->impl(), aPn2); } } else { aVec = gp_Vec(theDir->impl()); @@ -108,6 +229,7 @@ gp_Vec getVector(ObjectPtr theShape, GeomDirPtr theDir, gp_Pnt theP) return aVec; } +//***************************************************************** gp_Pnt SketcherPrs_PositionMgr::getPosition(ObjectPtr theShape, const SketcherPrs_SymbolPrs* thePrs, double theStep, GeomPointPtr thePnt) @@ -116,7 +238,7 @@ gp_Pnt SketcherPrs_PositionMgr::getPosition(ObjectPtr theShape, gp_Pnt aP; // Central point if (thePnt.get()) { - aP = thePnt->impl(); + return getPointPosition(theShape, thePrs, theStep, thePnt); } else { if (aShape->isEdge()) { std::shared_ptr aCurve = @@ -138,9 +260,9 @@ gp_Pnt SketcherPrs_PositionMgr::getPosition(ObjectPtr theShape, // Compute shifting vector for a one symbol gp_Vec aShift = aVec1.Crossed(thePrs->plane()->normal()->impl()); - aShift.Normalize(); - // For point based symbols step = 1.2, for line based = 0.8 - aShift.Multiply(theStep * (thePnt.get()? 1.2 : 0.8)); + if (aShift.SquareMagnitude() > Precision::SquareConfusion()) + aShift.Normalize(); + aShift.Multiply(theStep * 0.8); // Shift the position coordinate according to position index int aPos = getPositionIndex(theShape, thePrs); @@ -173,6 +295,183 @@ gp_Pnt SketcherPrs_PositionMgr::getPosition(ObjectPtr theShape, return aP; } + +//***************************************************************** +//! Returns curves connected to the given point +std::list getCurves(const GeomPointPtr& thePnt, const SketcherPrs_SymbolPrs* thePrs) +{ + std::list aList; + GeomAx3Ptr aAx3 = thePrs->plane(); + ModelAPI_CompositeFeature* aOwner = thePrs->sketcher(); + GeomPnt2dPtr aPnt2d = thePnt->to2D(aAx3->origin(), aAx3->dirX(), aAx3->dirY()); + + int aNbSubs = aOwner->numberOfSubs(); + for (int i = 0; i < aNbSubs; i++) { + FeaturePtr aFeature = aOwner->subFeature(i); + if (!aFeature->firstResult().get() || aFeature->firstResult()->isDisabled()) + continue; // There is no result + + if (aFeature->getKind() == SketchPlugin_Line::ID()) { + AttributePoint2DPtr aSPnt1 = std::dynamic_pointer_cast( + aFeature->data()->attribute(SketchPlugin_Line::START_ID())); + AttributePoint2DPtr aSPnt2 = std::dynamic_pointer_cast( + aFeature->data()->attribute(SketchPlugin_Line::END_ID())); + + GeomPnt2dPtr aPnt1 = aSPnt1->pnt(); + GeomPnt2dPtr aPnt2 = aSPnt2->pnt(); + + if (aPnt1->distance(aPnt2d) <= Precision::Confusion() || + aPnt2->distance(aPnt2d) <= Precision::Confusion()) { + // a point corresponds to one of the line end + GeomShapePtr aShp = SketcherPrs_Tools::getShape(aFeature->firstResult()); + GeomCurvePtr aCurv = std::shared_ptr(new GeomAPI_Curve(aShp)); + aList.push_back(aFeature->firstResult()); + } else { + // Check that a point belongs to the curve + GeomAPI_Lin2d aLin2d(aPnt1, aPnt2); + double aDist = aLin2d.distance(aPnt2d); + if (aDist <= Precision::Confusion()) + aList.push_back(aFeature->firstResult()); + } + } else { + GeomCurvePtr aCurve; + ObjectPtr aResObj; + std::list aResults = aFeature->results(); + std::list::const_iterator aIt; + for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) { + GeomShapePtr aShp = SketcherPrs_Tools::getShape((*aIt)); + if (aShp->isEdge()) { + aResObj = (*aIt); + aCurve = std::shared_ptr(new GeomAPI_Curve(aShp)); + break; + } + } + if (aCurve.get()) { + GeomPointPtr aProjPnt; + if (aFeature->getKind() == SketchPlugin_Circle::ID() || + aFeature->getKind() == SketchPlugin_Arc::ID()) { + GeomCirclePtr aCircle = GeomCirclePtr(new GeomAPI_Circ(aCurve)); + aProjPnt = aCircle->project(thePnt); + } + else if (aFeature->getKind() == SketchPlugin_Ellipse::ID()) { + GeomEllipsePtr anEllipse = GeomEllipsePtr(new GeomAPI_Ellipse(aCurve)); + aProjPnt = anEllipse->project(thePnt); + } + else + aProjPnt = aCurve->project(thePnt); + if (aProjPnt && thePnt->distance(aProjPnt) <= Precision::Confusion()) + aList.push_back(aResObj); + } + } + } + return aList; +} + +//***************************************************************** +gp_Pnt SketcherPrs_PositionMgr::getPointPosition( + ObjectPtr theLine, const SketcherPrs_SymbolPrs* thePrs, + double theStep, GeomPointPtr thePnt) +{ + gp_Pnt aP = thePnt->impl(); + if (!thePrs->plane().get()) + return aP; + GeomDirPtr aNormal = thePrs->plane()->normal(); + gp_Dir aNormDir = aNormal->impl(); + + std::list aCurves = getCurves(thePnt, thePrs); + std::list::const_iterator aItCurv; + std::list aVectorsList; + // Calculate all vectors + for (aItCurv = aCurves.cbegin(); aItCurv != aCurves.cend(); aItCurv++) { + aVectorsList.push_back(getVector((*aItCurv), thePrs->plane()->dirX(), aP)); + } + + // Position of the symbol + const std::array& aPos = getPositionIndex(thePnt, thePrs); + + // Angle size of a symbol + //double aAngleStep = PI * 50./180.; + double aAngleStep = PI/4.; + + std::list::const_iterator aItVec; + std::list aAngles; + std::list aVectors; + // Select closest vectors and calculate angles between base vector and closest vector + for (aItVec = aVectorsList.cbegin(); aItVec != aVectorsList.cend(); aItVec++) { + std::list::const_iterator aIt; + double aMinAng = 0; + gp_Vec aVec = *aItVec; + for (aIt = aVectorsList.cbegin(); aIt != aVectorsList.cend(); aIt++) { + double aAng = aVec.AngleWithRef(*aIt, aNormDir); + if (aAng != 0) { + if (aAng < 0) + aAng = 2 * PI + aAng; + + if (aMinAng == 0) + aMinAng = aAng; + else if (aAng < aMinAng) { + aMinAng = aAng; + } + } + } + if (aMinAng >= aAngleStep) { + aVectors.push_back(aVec); + aAngles.push_back(aMinAng); + } + } + + gp_Ax1 aRotAx(aP, aNormDir); + gp_Vec aVecPos; + // If number of angle less then number of symbols then each symbol can be placed + // directly inside of the angle + if ((int)aAngles.size() >= aPos[1] && !aVectors.empty()) { + int aId = aPos[0]; + aVecPos = *(std::next(aVectors.begin(), aId)); + + gp_Vec aShift = aVecPos.Rotated(aRotAx, aAngleStep); + aShift.Normalize(); + aShift.Multiply(theStep * 1.5); + return aP.Translated(aShift); + } + + // A case when there are a lot of symbols + int aPosCount = 0; + double aAng; + std::list::const_iterator aItAng; + + bool aHasPlace = false; + while (aPosCount < aPos[1]) { + for (aItAng = aAngles.cbegin(), aItVec = aVectors.cbegin(); + aItAng != aAngles.cend(); ++aItAng, ++aItVec) { + aAng = (*aItAng); + int Nb = int(aAng / aAngleStep); + aPosCount += Nb; + + if ((!aHasPlace) && (aPosCount >= (aPos[0] + 1))) { + aHasPlace = true; + aVecPos = (*aItVec); + } + } + if (aPosCount < aPos[1]) { + aAngleStep -= 0.1; + aHasPlace = false; + aPosCount = 0; + } + if (aAngleStep <= 0) + break; + } + + if (aHasPlace) { + // rotate base vector on a necessary angle + gp_Vec aShift = aVecPos.Rotated(aRotAx, aAngleStep + aAngleStep * aPos[0]); + aShift.Normalize(); + aShift.Multiply(theStep * 1.5); + return aP.Translated(aShift); + } + return aP; +} + +//***************************************************************** void SketcherPrs_PositionMgr::deleteConstraint(const SketcherPrs_SymbolPrs* thePrs) { std::map::iterator aIt; @@ -188,10 +487,10 @@ void SketcherPrs_PositionMgr::deleteConstraint(const SketcherPrs_SymbolPrs* theP aToDel.push_back(aIt->first); else { // Reindex objects positions in order to avoid spaces - PositionsMap::iterator aIt; + PositionsMap::iterator aPMIt; int i = 0; - for (aIt = aPosMap.begin(); aIt != aPosMap.end(); aIt++, i++) - aIt->second = i; + for (aPMIt = aPosMap.begin(); aPMIt != aPosMap.end(); aPMIt++, i++) + aPMIt->second = i; } } }