1 // Copyright (C) 2019-2020 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 #include <SketchPlugin_MacroBSpline.h>
22 #include <SketchPlugin_BSpline.h>
23 #include <SketchPlugin_BSplinePeriodic.h>
24 #include <SketchPlugin_ConstraintCoincidenceInternal.h>
25 #include <SketchPlugin_Line.h>
26 #include <SketchPlugin_Point.h>
27 #include <SketchPlugin_Tools.h>
28 #include <SketchPlugin_Sketch.h>
30 #include <ModelAPI_AttributeDoubleArray.h>
31 #include <ModelAPI_AttributeInteger.h>
32 #include <ModelAPI_AttributeRefAttrList.h>
33 #include <ModelAPI_Events.h>
34 #include <ModelAPI_EventReentrantMessage.h>
35 #include <ModelAPI_Session.h>
36 #include <ModelAPI_Validator.h>
38 #include <GeomDataAPI_Point2DArray.h>
40 #include <GeomAlgoAPI_CompoundBuilder.h>
41 #include <GeomAlgoAPI_EdgeBuilder.h>
42 #include <GeomAlgoAPI_PointBuilder.h>
44 #include <GeomAPI_BSpline2d.h>
48 /// Create internal coincidence constraint with B-spline pole
49 static void createInternalConstraint(SketchPlugin_Sketch* theSketch,
50 AttributePtr thePoint,
51 AttributePtr theBSplinePoles,
52 const int thePoleIndex);
55 SketchPlugin_MacroBSpline::SketchPlugin_MacroBSpline()
56 : SketchPlugin_SketchEntity(),
62 SketchPlugin_MacroBSpline::SketchPlugin_MacroBSpline(bool isPeriodic)
63 : SketchPlugin_SketchEntity(),
65 myIsPeriodic(isPeriodic)
69 void SketchPlugin_MacroBSpline::initAttributes()
71 data()->addAttribute(POLES_ID(), GeomDataAPI_Point2DArray::typeId());
72 data()->addAttribute(WEIGHTS_ID(), ModelAPI_AttributeDoubleArray::typeId());
74 data()->addAttribute(REF_POLES_ID(), ModelAPI_AttributeRefAttrList::typeId());
75 ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), REF_POLES_ID());
77 data()->addAttribute(CONTROL_POLYGON_ID(), ModelAPI_AttributeBoolean::typeId());
79 data()->addAttribute(AUXILIARY_ID(), ModelAPI_AttributeBoolean::typeId());
82 void SketchPlugin_MacroBSpline::execute()
84 FeaturePtr aBSpline = createBSplineFeature();
86 if (boolean(CONTROL_POLYGON_ID())->value()) {
87 std::list<FeaturePtr> aControlPoles;
88 createControlPolygon(aBSpline, aControlPoles);
89 constraintsForPoles(aControlPoles);
91 // message to init reentrant operation
92 static Events_ID anId = ModelAPI_EventReentrantMessage::eventId();
93 ReentrantMessagePtr aMessage(new ModelAPI_EventReentrantMessage(anId, this));
94 // set here the last pole to make coincidence with the start point of the next B-spline curve
95 aMessage->setCreatedFeature(aControlPoles.back());
96 Events_Loop::loop()->send(aMessage);
101 std::string SketchPlugin_MacroBSpline::processEvent(
102 const std::shared_ptr<Events_Message>& theMessage)
104 ReentrantMessagePtr aReentrantMessage =
105 std::dynamic_pointer_cast<ModelAPI_EventReentrantMessage>(theMessage);
106 if (aReentrantMessage) {
107 FeaturePtr aCreatedFeature = aReentrantMessage->createdFeature();
108 ObjectPtr anObject = aReentrantMessage->selectedObject();
109 AttributePtr anAttribute = aReentrantMessage->selectedAttribute();
110 std::shared_ptr<GeomAPI_Pnt2d> aClickedPoint = aReentrantMessage->clickedPoint();
113 // fill points list (it consists of 2 points to make editable the second one)
114 AttributePoint2DArrayPtr aPointArrayAttr =
115 std::dynamic_pointer_cast<GeomDataAPI_Point2DArray>(attribute(POLES_ID()));
116 aPointArrayAttr->setSize(2);
117 aPointArrayAttr->setPnt(0, aClickedPoint);
118 aPointArrayAttr->setPnt(1, aClickedPoint);
121 AttributeDoubleArrayPtr aWeightsArrayAttr = data()->realArray(WEIGHTS_ID());
122 aWeightsArrayAttr->setSize(2);
123 aWeightsArrayAttr->setValue(0, 1.0);
124 aWeightsArrayAttr->setValue(1, 1.0);
126 // fill reference attribute
127 AttributeRefAttrListPtr aRefAttrList =
128 std::dynamic_pointer_cast<ModelAPI_AttributeRefAttrList>(attribute(REF_POLES_ID()));
130 if (!anAttribute->owner() || !anAttribute->owner()->data()->isValid()) {
131 if (aCreatedFeature && anAttribute->id() == SketchPlugin_Point::COORD_ID())
132 anAttribute = aCreatedFeature->attribute(SketchPlugin_Point::COORD_ID());
134 aRefAttrList->append(anAttribute);
137 Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
139 return std::string();
143 FeaturePtr SketchPlugin_MacroBSpline::createBSplineFeature()
145 FeaturePtr aBSpline = sketch()->addFeature(
146 myIsPeriodic ? SketchPlugin_BSplinePeriodic::ID() : SketchPlugin_BSpline::ID());
148 aBSpline->integer(SketchPlugin_BSplineBase::DEGREE_ID())->setValue(myDegree);
150 AttributePoint2DArrayPtr aPoles = std::dynamic_pointer_cast<GeomDataAPI_Point2DArray>(
151 aBSpline->attribute(SketchPlugin_BSplineBase::POLES_ID()));
152 AttributePoint2DArrayPtr aPolesMacro =
153 std::dynamic_pointer_cast<GeomDataAPI_Point2DArray>(attribute(POLES_ID()));
154 aPoles->assign(aPolesMacro);
156 AttributeDoubleArrayPtr aWeights =
157 aBSpline->data()->realArray(SketchPlugin_BSplineBase::WEIGHTS_ID());
158 AttributeDoubleArrayPtr aWeightsMacro = data()->realArray(WEIGHTS_ID());
159 int aSize = aWeightsMacro->size();
160 aWeights->setSize(aSize);
161 for (int index = 0; index < aSize; ++index)
162 aWeights->setValue(index, aWeightsMacro->value(index));
164 AttributeDoubleArrayPtr aKnots =
165 aBSpline->data()->realArray(SketchPlugin_BSplineBase::KNOTS_ID());
166 aSize = (int)myKnots.size();
167 aKnots->setSize(aSize);
168 std::list<double>::iterator aKIt = myKnots.begin();
169 for (int index = 0; index < aSize; ++index, ++aKIt)
170 aKnots->setValue(index, *aKIt);
172 AttributeIntArrayPtr aMults = aBSpline->data()->intArray(SketchPlugin_BSplineBase::MULTS_ID());
173 aSize = (int)myMultiplicities.size();
174 aMults->setSize(aSize);
175 std::list<int>::iterator aMIt = myMultiplicities.begin();
176 for (int index = 0; index < aSize; ++index, ++aMIt)
177 aMults->setValue(index, *aMIt);
180 AttributePoint2DPtr aStartPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
181 aBSpline->attribute(SketchPlugin_BSpline::START_ID()));
182 aStartPoint->setValue(aPoles->pnt(0));
184 AttributePoint2DPtr aEndPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
185 aBSpline->attribute(SketchPlugin_BSpline::END_ID()));
186 aEndPoint->setValue(aPoles->pnt(aPoles->size() - 1));
189 aBSpline->boolean(SketchPlugin_SketchEntity::AUXILIARY_ID())->setValue(
190 boolean(AUXILIARY_ID())->value());
197 void SketchPlugin_MacroBSpline::createControlPolygon(FeaturePtr theBSpline,
198 std::list<FeaturePtr>& thePoles)
200 AttributePoint2DArrayPtr aPoles = std::dynamic_pointer_cast<GeomDataAPI_Point2DArray>(
201 theBSpline->attribute(SketchPlugin_BSpline::POLES_ID()));
202 int aSize = aPoles->size();
204 for (int index = 0; index < aSize; ++index)
205 thePoles.push_back(createAuxiliaryPole(aPoles, index));
207 for (int index = 1; index < aSize; ++index)
208 createAuxiliarySegment(aPoles, index - 1, index);
210 // additional segment to close the control polygon
211 createAuxiliarySegment(aPoles, aSize - 1, 0);
215 void SketchPlugin_MacroBSpline::constraintsForPoles(const std::list<FeaturePtr>& thePoles)
217 AttributeRefAttrListPtr aRefAttrList = data()->refattrlist(REF_POLES_ID());
218 std::list<std::pair<ObjectPtr, AttributePtr> > aList;
220 aList = aRefAttrList->list();
222 SketchPlugin_Sketch* aSketch = sketch();
224 std::list<std::pair<ObjectPtr, AttributePtr> >::iterator aLIt = aList.begin();
225 std::list<FeaturePtr>::const_iterator aPIt = thePoles.begin();
226 for (; aLIt != aList.end() && aPIt != thePoles.end(); ++aPIt, ++aLIt) {
227 // firstly, check the attribute (in this case the object will be not empty too)
229 SketchPlugin_Tools::createConstraintAttrAttr(aSketch,
230 SketchPlugin_ConstraintCoincidence::ID(),
231 (*aPIt)->attribute(SketchPlugin_Point::COORD_ID()), aLIt->second);
233 // now add coincidence with the result
234 else if (aLIt->first) {
235 SketchPlugin_Tools::createConstraintAttrObject(aSketch,
236 SketchPlugin_ConstraintCoincidence::ID(),
237 (*aPIt)->attribute(SketchPlugin_Point::COORD_ID()), aLIt->first);
242 AISObjectPtr SketchPlugin_MacroBSpline::getAISObject(AISObjectPtr thePrevious)
244 SketchPlugin_Sketch* aSketch = sketch();
246 return AISObjectPtr();
248 AttributePoint2DArrayPtr aPolesArray =
249 std::dynamic_pointer_cast<GeomDataAPI_Point2DArray>(attribute(POLES_ID()));
250 AttributeDoubleArrayPtr aWeightsArray = data()->realArray(WEIGHTS_ID());
252 if (aPolesArray->size() < 2)
253 return AISObjectPtr();
255 std::list<GeomShapePtr> aShapes;
257 // convert poles to vertices and collect weights
258 std::list<GeomPnt2dPtr> aPoles2D;
259 std::list<double> aWeights;
260 for (int anIndex = 0; anIndex < aPolesArray->size(); ++anIndex) {
261 double aWeight = aWeightsArray->value(anIndex);
262 if (aWeight < 1.e-10)
263 continue; // skip poles with zero weights
265 aWeights.push_back(aWeight);
267 GeomPnt2dPtr aPole = aPolesArray->pnt(anIndex);
268 aPoles2D.push_back(aPole);
269 GeomPointPtr aPole3D = aSketch->to3D(aPole->x(), aPole->y());
270 aShapes.push_back(GeomAlgoAPI_PointBuilder::vertex(aPole3D));
273 // create result non-periodic B-spline curve
274 std::shared_ptr<GeomAPI_BSpline2d> aBSplineCurve;
276 aBSplineCurve.reset(new GeomAPI_BSpline2d(aPoles2D, aWeights, myIsPeriodic));
278 // cannot build a B-spline curve
279 return AISObjectPtr();
281 GeomShapePtr anEdge =
282 GeomAlgoAPI_EdgeBuilder::bsplineOnPlane(aSketch->coordinatePlane(), aBSplineCurve);
284 return AISObjectPtr();
286 // store transient parameters of B-spline curve
287 myDegree = aBSplineCurve->degree();
288 myKnots = aBSplineCurve->knots();
289 myMultiplicities = aBSplineCurve->mults();
291 aShapes.push_back(anEdge);
292 GeomShapePtr aCompound = GeomAlgoAPI_CompoundBuilder::compound(aShapes);
294 AISObjectPtr anAIS = thePrevious;
296 anAIS.reset(new GeomAPI_AISObject());
297 anAIS->createShape(aCompound);
300 SketchPlugin_Tools::customizeFeaturePrs(anAIS, boolean(AUXILIARY_ID())->value());
307 // ========================== Auxiliary functions ===========================================
309 FeaturePtr SketchPlugin_MacroBSpline::createAuxiliaryPole(AttributePoint2DArrayPtr theBSplinePoles,
310 const int thePoleIndex)
312 FeaturePtr aBSpline = ModelAPI_Feature::feature(theBSplinePoles->owner());
314 SketchPlugin_Sketch* aSketch =
315 std::dynamic_pointer_cast<SketchPlugin_Feature>(aBSpline)->sketch();
317 // create child point equal to the B-spline's pole
318 FeaturePtr aPointFeature = aSketch->addFeature(SketchPlugin_Point::ID());
319 aPointFeature->boolean(SketchPlugin_Point::AUXILIARY_ID())->setValue(true);
320 aPointFeature->reference(SketchPlugin_Point::PARENT_ID())->setValue(aBSpline);
322 GeomPnt2dPtr aPole = theBSplinePoles->pnt(thePoleIndex);
324 AttributePoint2DPtr aCoord = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
325 aPointFeature->attribute(SketchPlugin_Point::COORD_ID()));
326 aCoord->setValue(aPole);
328 aPointFeature->execute();
330 std::ostringstream aName;
331 aName << aBSpline->name() << "_" << theBSplinePoles->id() << "_" << thePoleIndex;
332 aPointFeature->data()->setName(aName.str());
333 aPointFeature->lastResult()->data()->setName(aName.str());
335 // internal constraint to keep position of the point
336 createInternalConstraint(aSketch, aCoord, theBSplinePoles, thePoleIndex);
338 return aPointFeature;
341 void SketchPlugin_MacroBSpline::createAuxiliarySegment(AttributePoint2DArrayPtr theBSplinePoles,
342 const int thePoleIndex1,
343 const int thePoleIndex2)
345 FeaturePtr aBSpline = ModelAPI_Feature::feature(theBSplinePoles->owner());
347 SketchPlugin_Sketch* aSketch =
348 std::dynamic_pointer_cast<SketchPlugin_Feature>(aBSpline)->sketch();
350 // create child segment between B-spline poles
351 FeaturePtr aLineFeature = aSketch->addFeature(SketchPlugin_Line::ID());
352 aLineFeature->boolean(SketchPlugin_Point::AUXILIARY_ID())->setValue(true);
353 aLineFeature->reference(SketchPlugin_Point::PARENT_ID())->setValue(aBSpline);
355 AttributePoint2DPtr aLineStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
356 aLineFeature->attribute(SketchPlugin_Line::START_ID()));
357 aLineStart->setValue(theBSplinePoles->pnt(thePoleIndex1));
359 AttributePoint2DPtr aLineEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
360 aLineFeature->attribute(SketchPlugin_Line::END_ID()));
361 aLineEnd->setValue(theBSplinePoles->pnt(thePoleIndex2));
363 aLineFeature->execute();
365 std::ostringstream aName;
366 aName << aBSpline->name() << "_segment_" << thePoleIndex1 << "_" << thePoleIndex2;
367 aLineFeature->data()->setName(aName.str());
368 aLineFeature->lastResult()->data()->setName(aName.str());
370 // internal constraints to keep the segment position
371 createInternalConstraint(aSketch, aLineStart, theBSplinePoles, thePoleIndex1);
372 createInternalConstraint(aSketch, aLineEnd, theBSplinePoles, thePoleIndex2);
375 void createInternalConstraint(SketchPlugin_Sketch* theSketch,
376 AttributePtr thePoint,
377 AttributePtr theBSplinePoles,
378 const int thePoleIndex)
380 std::shared_ptr<SketchPlugin_ConstraintCoincidenceInternal> aConstraint =
381 std::dynamic_pointer_cast<SketchPlugin_ConstraintCoincidenceInternal>(
382 theSketch->addFeature(SketchPlugin_ConstraintCoincidenceInternal::ID()));
383 aConstraint->refattr(SketchPlugin_Constraint::ENTITY_A())->setAttr(thePoint);
384 aConstraint->refattr(SketchPlugin_Constraint::ENTITY_B())->setAttr(theBSplinePoles);
385 aConstraint->integer(SketchPlugin_ConstraintCoincidenceInternal::INDEX_ENTITY_B())
386 ->setValue(thePoleIndex);