src/SketcherPrs/SketcherPrs_PositionMgr.cpp

   1 // Copyright (C) 2014-2019  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "SketcherPrs_PositionMgr.h"
  21 #include "SketcherPrs_Tools.h"
  22
  23 #include <GeomAPI_Ax3.h>
  24 #include <GeomAPI_Circ.h>
  25 #include <GeomAPI_Curve.h>
  26 #include <GeomAPI_Edge.h>
  27 #include <GeomAPI_Ellipse.h>
  28 #include <GeomAPI_Dir.h>
  29 #include <GeomAPI_Lin2d.h>
  30 #include <GeomAPI_Vertex.h>
  31
  32 #include <GeomDataAPI_Point2D.h>
  33
  34 #include <SketchPlugin_Arc.h>
  35 #include <SketchPlugin_Circle.h>
  36 #include <SketchPlugin_Ellipse.h>
  37 #include <SketchPlugin_Line.h>
  38 #include <SketchPlugin_ConstraintPerpendicular.h>
  39 #include <SketchPlugin_ConstraintTangent.h>
  40
  41 #include <TopoDS_Vertex.hxx>
  42 #include <Geom_Curve.hxx>
  43 #include <GeomAPI_ProjectPointOnCurve.hxx>
  44 #include <TColGeom_SequenceOfCurve.hxx>
  45 #include <gp_Dir.hxx>
  46
  47 #include <array>
  48
  49 static SketcherPrs_PositionMgr* MyPosMgr = NULL;
  50
  51 #define PI 3.1415926535897932
  52
  53 // The class is implemented as a singlton
  54 SketcherPrs_PositionMgr* SketcherPrs_PositionMgr::get()
  55 {
  56   if (MyPosMgr == NULL)
  57     MyPosMgr = new SketcherPrs_PositionMgr();
  58   return MyPosMgr;
  59 }
  60
  61 SketcherPrs_PositionMgr::SketcherPrs_PositionMgr()
  62 {
  63 }
  64
  65 int SketcherPrs_PositionMgr::getPositionIndex(ObjectPtr theLine,
  66                                               const SketcherPrs_SymbolPrs* thePrs)
  67 {
  68   if (myShapes.count(theLine) == 1) {
  69     // Find the map and add new [Presentation - Index] pair
  70     PositionsMap& aPosMap = myShapes[theLine];
  71     if (aPosMap.count(thePrs) == 1) {
  72       // return existing index
  73       return aPosMap[thePrs];
  74     } else {
  75       // Add a new [Presentation - Index] pair
  76       int aInd = int(aPosMap.size());
  77       aPosMap[thePrs] = aInd;
  78       return aInd;
  79     }
  80   } else {
  81     // Create a new map with initial index
  82     PositionsMap aPosMap;
  83     aPosMap[thePrs] = 0;
  84     myShapes[theLine] = aPosMap;
  85     return 0;
  86   }
  87 }
  88
  89
  90 bool SketcherPrs_PositionMgr::isPntConstraint(const std::string& theName)
  91 {
  92   return ((theName == SketchPlugin_ConstraintTangent::ID()) ||
  93     (theName == SketchPlugin_ConstraintPerpendicular::ID()));
  94 }
  95
  96 bool containsPoint(const FeaturePtr& theFeature, GeomPnt2dPtr thePnt2d, GeomPointPtr thePos)
  97 {
  98   if (theFeature->getKind() == SketchPlugin_Line::ID()) {
  99     AttributePoint2DPtr aSPnt1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 100       theFeature->data()->attribute(SketchPlugin_Line::START_ID()));
 101     AttributePoint2DPtr aSPnt2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 102       theFeature->data()->attribute(SketchPlugin_Line::END_ID()));
 103
 104     GeomPnt2dPtr aPnt1 = aSPnt1->pnt();
 105     GeomPnt2dPtr aPnt2 = aSPnt2->pnt();
 106
 107     if (aPnt1->isEqual(thePnt2d) || aPnt2->isEqual(thePnt2d))
 108       return true;
 109   } else if ((theFeature->getKind() == SketchPlugin_Circle::ID()) ||
 110              (theFeature->getKind() == SketchPlugin_Arc::ID())) {
 111     GeomCurvePtr aCurve;
 112     ObjectPtr aResObj;
 113     std::list<ResultPtr> aResults = theFeature->results();
 114     std::list<ResultPtr>::const_iterator aIt;
 115     for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
 116       GeomShapePtr aShp = SketcherPrs_Tools::getShape((*aIt));
 117       if (aShp->isEdge()) {
 118         aResObj = (*aIt);
 119         aCurve = std::shared_ptr<GeomAPI_Curve>(new GeomAPI_Curve(aShp));
 120         break;
 121       }
 122     }
 123     if (aCurve.get()) {
 124       double aStart = aCurve->startParam();
 125       double aEnd = aCurve->endParam();
 126       GeomCirclePtr  aCircle = GeomCirclePtr(new GeomAPI_Circ(aCurve));
 127       double aParam;
 128       if (aCircle->parameter(thePos, 1.e-4, aParam) && (aParam >= aStart) && (aParam <= aEnd))
 129         return true;
 130     }
 131   }
 132   return false;
 133 }
 134
 135 const std::array<int, 2>& SketcherPrs_PositionMgr::getPositionIndex(GeomPointPtr thePos,
 136                                               const SketcherPrs_SymbolPrs* thePrs)
 137 {
 138   if (myPntShapes.count(thePrs->feature()) == 0) {
 139     // Renumerate positions around the specified constraint point for all constraints
 140     GeomAx3Ptr aAx3 = thePrs->plane();
 141     ModelAPI_CompositeFeature* aOwner = thePrs->sketcher();
 142     GeomPnt2dPtr aPnt2d = thePos->to2D(aAx3->origin(), aAx3->dirX(), aAx3->dirY());
 143
 144     int aNbSubs = aOwner->numberOfSubs();
 145     int aId = 0;
 146     std::list<const ModelAPI_Feature*> aFeaList;
 147     for (int i = 0; i < aNbSubs; i++) {
 148       FeaturePtr aFeature = aOwner->subFeature(i);
 149
 150       bool aUseFeature = ((myPntShapes.count(aFeature.get()) == 1) ||
 151                          (isPntConstraint(aFeature->getKind())));
 152       if (aUseFeature) {
 153         DataPtr aData = aFeature->data();
 154         AttributeRefAttrPtr aObjRef = aData->refattr(SketchPlugin_Constraint::ENTITY_A());
 155         FeaturePtr aObj;
 156         if (aObjRef)
 157           aObj = ModelAPI_Feature::feature(aObjRef->object());
 158         bool aContains = false;
 159         if (aObj && containsPoint(aObj, aPnt2d, thePos)) {
 160           aContains = true;
 161         } else {
 162           aObjRef = aData->refattr(SketchPlugin_Constraint::ENTITY_B());
 163           if (aObjRef)
 164             aObj = ModelAPI_Feature::feature(aObjRef->object());
 165           if (aObj && containsPoint(aObj, aPnt2d, thePos)) {
 166             aContains = true;
 167           }
 168         }
 169         if (aContains) {
 170           myPntShapes[aFeature.get()][0] = aId;
 171           aId++;
 172           aFeaList.push_back(aFeature.get());
 173         }
 174       }
 175     }
 176     int aSize = (int) aFeaList.size();
 177     std::list<const ModelAPI_Feature*>::const_iterator aIt;
 178     for (aIt = aFeaList.cbegin(); aIt != aFeaList.cend(); aIt++) {
 179       myPntShapes[*aIt][1] = aSize;
 180     }
 181   }
 182   return myPntShapes[thePrs->feature()];
 183 }
 184
 185 //*****************************************************************
 186 gp_Vec getVector(ObjectPtr theShape, GeomDirPtr theDir, gp_Pnt theP)
 187 {
 188   gp_Vec aVec;
 189   std::shared_ptr<GeomAPI_Shape> aShape = SketcherPrs_Tools::getShape(theShape);
 190   if (aShape->isEdge()) {
 191     std::shared_ptr<GeomAPI_Edge> anEdge = aShape->edge();
 192     std::shared_ptr<GeomAPI_Curve> aCurve =
 193       std::shared_ptr<GeomAPI_Curve>(new GeomAPI_Curve(aShape));
 194
 195     if (anEdge->isClosed()) {
 196       double aPeriod = aCurve->endParam() - aCurve->startParam();
 197       Handle(Geom_Curve) aCurv = aCurve->impl<Handle_Geom_Curve>();
 198       GeomAPI_ProjectPointOnCurve anExtr(theP, aCurv);
 199       double aParam = anExtr.LowerDistanceParameter();
 200       gp_Pnt aP;
 201       aCurv->D1(aParam, aP, aVec);
 202       // 2458: check correct orientation of the vector
 203       if (aVec.SquareMagnitude() > Precision::Confusion()) {
 204         std::shared_ptr<GeomAPI_Edge> aCircEdge(new GeomAPI_Edge(aShape));
 205         double aFirstParam, aLastParam;
 206         aCircEdge->getRange(aFirstParam, aLastParam);
 207         // if parameter is near the LastParam, make the vector go inside (reverse)
 208         double aDelta = aLastParam - aParam;
 209         while (aDelta < -Precision::Confusion())
 210           aDelta += aPeriod;
 211         while (aDelta > aPeriod + Precision::Confusion())
 212           aDelta -= aPeriod;
 213         if (fabs(aDelta) < Precision::Confusion())
 214           aVec.Reverse();
 215       }
 216     } else {
 217       GeomPointPtr aPnt1 = aCurve->getPoint(aCurve->endParam());
 218       GeomPointPtr aPnt2 = aCurve->getPoint(aCurve->startParam());
 219
 220       gp_Pnt aPn2 = aPnt2->impl<gp_Pnt>();
 221       if (aPn2.IsEqual(theP, Precision::Confusion()))
 222         aVec = gp_Vec(aPn2, aPnt1->impl<gp_Pnt>());
 223       else
 224         aVec = gp_Vec(aPnt1->impl<gp_Pnt>(), aPn2);
 225     }
 226   } else {
 227     aVec = gp_Vec(theDir->impl<gp_Dir>());
 228   }
 229   return aVec;
 230 }
 231
 232 //*****************************************************************
 233 gp_Pnt SketcherPrs_PositionMgr::getPosition(ObjectPtr theShape,
 234                                             const SketcherPrs_SymbolPrs* thePrs,
 235                                             double theStep, GeomPointPtr thePnt)
 236 {
 237   std::shared_ptr<GeomAPI_Shape> aShape = SketcherPrs_Tools::getShape(theShape);
 238   gp_Pnt aP; // Central point
 239
 240   if (thePnt.get()) {
 241     return getPointPosition(theShape, thePrs, theStep, thePnt);
 242   } else {
 243     if (aShape->isEdge()) {
 244       std::shared_ptr<GeomAPI_Curve> aCurve =
 245         std::shared_ptr<GeomAPI_Curve>(new GeomAPI_Curve(aShape));
 246       // this is a circle or arc
 247       double aMidParam = (aCurve->startParam() + aCurve->endParam()) / 2.;
 248       std::shared_ptr<GeomAPI_Pnt> aPnt = aCurve->getPoint(aMidParam);
 249       aP = aPnt->impl<gp_Pnt>();
 250     } else {
 251       // This is a point
 252       std::shared_ptr<GeomAPI_Vertex> aVertex =
 253         std::shared_ptr<GeomAPI_Vertex>(new GeomAPI_Vertex(aShape));
 254       std::shared_ptr<GeomAPI_Pnt> aPnt = aVertex->point();
 255       aP = aPnt->impl<gp_Pnt>();
 256     }
 257   }
 258   // main vector
 259   gp_Vec aVec1 = getVector(theShape, thePrs->plane()->dirX(), aP);
 260
 261   // Compute shifting vector for a one symbol
 262   gp_Vec aShift = aVec1.Crossed(thePrs->plane()->normal()->impl<gp_Dir>());
 263   aShift.Normalize();
 264   aShift.Multiply(theStep * 0.8);
 265
 266   // Shift the position coordinate according to position index
 267   int aPos = getPositionIndex(theShape, thePrs);
 268   int aM = 1;
 269   if ((aPos % 2) == 0) {
 270     // Even position
 271     aP.Translate(aShift);
 272     if (aPos > 0) {
 273       if (aPos % 4 == 0)
 274         aM = aPos / 4;
 275       else
 276         aM = -(aPos + 2) / 4;
 277     }
 278   } else {
 279     // Odd position
 280     aP.Translate(-aShift);
 281     if (aPos > 1) {
 282       if ((aPos - 1) % 4 == 0)
 283         aM = (aPos - 1) / 4;
 284       else
 285         aM = -(aPos + 1) / 4;
 286     }
 287   }
 288   if (aPos > 1) {
 289     // Normalize vector along the line
 290     aVec1.Normalize();
 291     aVec1.Multiply(theStep);
 292     aP.Translate(aVec1.Multiplied(aM));
 293   }
 294   return aP;
 295 }
 296
 297
 298 //*****************************************************************
 299 //! Returns curves connected to the given point
 300 std::list<ObjectPtr> getCurves(const GeomPointPtr& thePnt, const SketcherPrs_SymbolPrs* thePrs)
 301 {
 302   std::list<ObjectPtr> aList;
 303   GeomAx3Ptr aAx3 = thePrs->plane();
 304   ModelAPI_CompositeFeature* aOwner = thePrs->sketcher();
 305   GeomPnt2dPtr aPnt2d = thePnt->to2D(aAx3->origin(), aAx3->dirX(), aAx3->dirY());
 306
 307   int aNbSubs = aOwner->numberOfSubs();
 308   for (int i = 0; i < aNbSubs; i++) {
 309     FeaturePtr aFeature = aOwner->subFeature(i);
 310     if (!aFeature->firstResult().get() || aFeature->firstResult()->isDisabled())
 311       continue;  // There is no result
 312
 313     if (aFeature->getKind() == SketchPlugin_Line::ID()) {
 314       AttributePoint2DPtr aSPnt1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 315         aFeature->data()->attribute(SketchPlugin_Line::START_ID()));
 316       AttributePoint2DPtr aSPnt2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 317         aFeature->data()->attribute(SketchPlugin_Line::END_ID()));
 318
 319       GeomPnt2dPtr aPnt1 = aSPnt1->pnt();
 320       GeomPnt2dPtr aPnt2 = aSPnt2->pnt();
 321
 322       if (aPnt1->distance(aPnt2d) <= Precision::Confusion() ||
 323           aPnt2->distance(aPnt2d) <= Precision::Confusion()) {
 324         // a point corresponds to one of the line end
 325         GeomShapePtr aShp = SketcherPrs_Tools::getShape(aFeature->firstResult());
 326         GeomCurvePtr aCurv = std::shared_ptr<GeomAPI_Curve>(new GeomAPI_Curve(aShp));
 327         aList.push_back(aFeature->firstResult());
 328       } else {
 329         // Check that a point belongs to the curve
 330         GeomAPI_Lin2d aLin2d(aPnt1, aPnt2);
 331         double aDist = aLin2d.distance(aPnt2d);
 332         if (aDist <= Precision::Confusion())
 333           aList.push_back(aFeature->firstResult());
 334       }
 335     } else {
 336       GeomCurvePtr aCurve;
 337       ObjectPtr aResObj;
 338       std::list<ResultPtr> aResults = aFeature->results();
 339       std::list<ResultPtr>::const_iterator aIt;
 340       for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
 341         GeomShapePtr aShp = SketcherPrs_Tools::getShape((*aIt));
 342         if (aShp->isEdge()) {
 343           aResObj = (*aIt);
 344           aCurve = std::shared_ptr<GeomAPI_Curve>(new GeomAPI_Curve(aShp));
 345           break;
 346         }
 347       }
 348       if (aCurve.get()) {
 349         GeomPointPtr aProjPnt;
 350         if (aFeature->getKind() == SketchPlugin_Circle::ID() ||
 351           aFeature->getKind() == SketchPlugin_Arc::ID()) {
 352           GeomCirclePtr aCircle = GeomCirclePtr(new GeomAPI_Circ(aCurve));
 353           aProjPnt = aCircle->project(thePnt);
 354         }
 355         else if (aFeature->getKind() == SketchPlugin_Ellipse::ID()) {
 356           GeomEllipsePtr anEllipse = GeomEllipsePtr(new GeomAPI_Ellipse(aCurve));
 357           aProjPnt = anEllipse->project(thePnt);
 358         }
 359         else
 360           aProjPnt = aCurve->project(thePnt);
 361         if (aProjPnt && thePnt->distance(aProjPnt) <= Precision::Confusion())
 362           aList.push_back(aResObj);
 363       }
 364     }
 365   }
 366   return aList;
 367 }
 368
 369 //*****************************************************************
 370 gp_Pnt SketcherPrs_PositionMgr::getPointPosition(
 371   ObjectPtr theLine, const SketcherPrs_SymbolPrs* thePrs,
 372   double theStep, GeomPointPtr thePnt)
 373 {
 374   gp_Pnt aP = thePnt->impl<gp_Pnt>();
 375   if (!thePrs->plane().get())
 376     return aP;
 377   GeomDirPtr aNormal = thePrs->plane()->normal();
 378   gp_Dir aNormDir = aNormal->impl<gp_Dir>();
 379
 380   std::list<ObjectPtr> aCurves = getCurves(thePnt, thePrs);
 381   std::list<ObjectPtr>::const_iterator aItCurv;
 382   std::list<gp_Vec> aVectorsList;
 383   // Calculate all vectors
 384   for (aItCurv = aCurves.cbegin(); aItCurv != aCurves.cend(); aItCurv++) {
 385     aVectorsList.push_back(getVector((*aItCurv), thePrs->plane()->dirX(), aP));
 386   }
 387
 388   // Position of the symbol
 389   const std::array<int, 2>& aPos = getPositionIndex(thePnt, thePrs);
 390
 391   // Angle size of a symbol
 392   //double aAngleStep = PI * 50./180.;
 393   double aAngleStep = PI/4.;
 394
 395   std::list<gp_Vec>::const_iterator aItVec;
 396   std::list<double> aAngles;
 397   std::list<gp_Vec> aVectors;
 398   // Select closest vectors and calculate angles between base vector and closest vector
 399   for (aItVec = aVectorsList.cbegin(); aItVec != aVectorsList.cend(); aItVec++) {
 400     std::list<gp_Vec>::const_iterator aIt;
 401     double aMinAng = 0;
 402     gp_Vec aVec = *aItVec;
 403     for (aIt = aVectorsList.cbegin(); aIt != aVectorsList.cend(); aIt++) {
 404       double aAng = aVec.AngleWithRef(*aIt, aNormDir);
 405       if (aAng != 0) {
 406         if (aAng < 0)
 407           aAng = 2 * PI + aAng;
 408
 409         if (aMinAng == 0)
 410           aMinAng = aAng;
 411         else if (aAng < aMinAng) {
 412           aMinAng = aAng;
 413         }
 414       }
 415     }
 416     if (aMinAng >= aAngleStep) {
 417       aVectors.push_back(aVec);
 418       aAngles.push_back(aMinAng);
 419     }
 420   }
 421
 422   gp_Ax1 aRotAx(aP, aNormDir);
 423   gp_Vec aVecPos;
 424   // If number of angle less then number of symbols then each symbol can be placed
 425   // directly inside of the angle
 426   if (aAngles.size() >= aPos[1] && !aVectors.empty()) {
 427     int aId = aPos[0];
 428     aVecPos = *(std::next(aVectors.begin(), aId));
 429
 430     gp_Vec aShift = aVecPos.Rotated(aRotAx, aAngleStep);
 431     aShift.Normalize();
 432     aShift.Multiply(theStep * 1.5);
 433     return aP.Translated(aShift);
 434   }
 435
 436   // A case when there are a lot of symbols
 437   int aPosCount = 0;
 438   double aAng;
 439   std::list<double>::const_iterator aItAng;
 440
 441   double aAngPos;
 442   bool aHasPlace = false;
 443   //int aIntId = 0; // a position inside a one sector
 444   while (aPosCount < aPos[1]) {
 445     for (aItAng = aAngles.cbegin(), aItVec = aVectors.cbegin();
 446          aItAng != aAngles.cend(); ++aItAng, ++aItVec) {
 447       aAng = (*aItAng);
 448       int Nb = int(aAng / aAngleStep);
 449       aPosCount += Nb;
 450
 451       if ((!aHasPlace) && (aPosCount >= (aPos[0] + 1))) {
 452         aHasPlace = true;
 453         aAngPos = (*aItAng);
 454         aVecPos = (*aItVec);
 455         //aIntId = aPos[0] - (aPosCount - Nb);
 456       }
 457     }
 458     if (aPosCount < aPos[1]) {
 459       aAngleStep -= 0.1;
 460       aHasPlace = false;
 461       aPosCount = 0;
 462     }
 463     if (aAngleStep <= 0)
 464       break;
 465   }
 466
 467   if (aHasPlace) {
 468     // rotate base vector on a necessary angle
 469     gp_Vec aShift = aVecPos.Rotated(aRotAx, aAngleStep + aAngleStep * aPos[0]);
 470     aShift.Normalize();
 471     aShift.Multiply(theStep * 1.5);
 472     return aP.Translated(aShift);
 473   }
 474   return aP;
 475 }
 476
 477 //*****************************************************************
 478 void SketcherPrs_PositionMgr::deleteConstraint(const SketcherPrs_SymbolPrs* thePrs)
 479 {
 480   std::map<ObjectPtr, PositionsMap>::iterator aIt;
 481   std::list<ObjectPtr> aToDel;
 482   // Clear map for deleted presentation
 483   for (aIt = myShapes.begin(); aIt != myShapes.end(); ++aIt) {
 484     PositionsMap& aPosMap = aIt->second;
 485     if (aPosMap.count(thePrs) > 0) {
 486       // Erase index
 487       aPosMap.erase(aPosMap.find(thePrs));
 488       if (aPosMap.size() == 0)
 489         // Delete the map
 490         aToDel.push_back(aIt->first);
 491       else {
 492         // Reindex objects positions in order to avoid spaces
 493         PositionsMap::iterator aIt;
 494         int i = 0;
 495         for (aIt = aPosMap.begin(); aIt != aPosMap.end(); aIt++, i++)
 496           aIt->second = i;
 497       }
 498     }
 499   }
 500   std::list<ObjectPtr>::const_iterator aListIt;
 501   for (aListIt = aToDel.cbegin(); aListIt != aToDel.cend(); ++aListIt) {
 502     myShapes.erase(*aListIt);
 503   }
 504 }