X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchAPI%2FSketchAPI_Sketch.cpp;h=823897f5a6e2213e98c2a0e07d3fa8fd79e7f0ec;hb=fc72d43b677baa05ae7fd317346fd8b723b799ed;hp=b2ca766988edd68862c7c6894ec35672e5de608e;hpb=4bccf0ccd2f13dca7b9d16c59f427dea91c289fa;p=modules%2Fshaper.git diff --git a/src/SketchAPI/SketchAPI_Sketch.cpp b/src/SketchAPI/SketchAPI_Sketch.cpp index b2ca76698..823897f5a 100644 --- a/src/SketchAPI/SketchAPI_Sketch.cpp +++ b/src/SketchAPI/SketchAPI_Sketch.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2019 CEA/DEN, EDF R&D +// Copyright (C) 2014-2023 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 @@ -36,10 +36,14 @@ #include #include #include +#include #include #include #include #include +#include +#include +#include #include //-------------------------------------------------------------------------------------- #include @@ -53,6 +57,7 @@ #include //-------------------------------------------------------------------------------------- #include "SketchAPI_Arc.h" +#include "SketchAPI_BSpline.h" #include "SketchAPI_Circle.h" #include "SketchAPI_Ellipse.h" #include "SketchAPI_EllipticArc.h" @@ -63,6 +68,7 @@ #include "SketchAPI_MacroEllipse.h" #include "SketchAPI_MacroEllipticArc.h" #include "SketchAPI_Mirror.h" +#include "SketchAPI_Offset.h" #include "SketchAPI_Point.h" #include "SketchAPI_Projection.h" #include "SketchAPI_Rectangle.h" @@ -75,6 +81,8 @@ #include #include #include + +#include #include //-------------------------------------------------------------------------------------- SketchAPI_Sketch::SketchAPI_Sketch( @@ -215,7 +223,7 @@ SketchPtr addSketch(const std::shared_ptr & thePart, } SketchPtr addSketch(const std::shared_ptr & thePart, - const std::string & theExternalName) + const std::wstring & theExternalName) { std::shared_ptr aFeature = thePart->addFeature(SketchAPI_Sketch::ID()); return SketchPtr( @@ -229,6 +237,23 @@ SketchPtr addSketch(const std::shared_ptr & thePart, return SketchPtr(new SketchAPI_Sketch(aFeature, thePlaneObject)); } +//-------------------------------------------------------------------------------------- +SketchPtr copySketch(const std::shared_ptr & thePart, + const SketchPtr & theSketch) +{ + FeaturePtr aCopyer = thePart->addFeature(SketchPlugin_SketchCopy::ID()); + aCopyer->reference(SketchPlugin_SketchCopy::BASE_ID())->setValue(theSketch->feature()); + aCopyer->execute(); + + FeaturePtr aNewSketch = thePart->nextFeature(aCopyer); + + // perform removing the macro-feature + thePart->removeFeature(aCopyer); + apply(); + + return SketchPtr(new SketchAPI_Sketch(aNewSketch)); +} + //-------------------------------------------------------------------------------------- std::list< std::shared_ptr > SketchAPI_Sketch::getFreePoints() @@ -324,7 +349,7 @@ std::shared_ptr compositeFeature()->addFeature(SketchPlugin_Point::ID()); return PointPtr(new SketchAPI_Point(aFeature, theExternal)); } -std::shared_ptr SketchAPI_Sketch::addPoint(const std::string & theExternalName) +std::shared_ptr SketchAPI_Sketch::addPoint(const std::wstring & theExternalName) { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Point::ID()); @@ -343,7 +368,7 @@ std::shared_ptr SketchAPI_Sketch::addIntersectionPo return anIntersection; } std::shared_ptr SketchAPI_Sketch::addIntersectionPoint( - const std::string & theExternalName, + const std::wstring & theExternalName, bool theKeepResult) { std::shared_ptr aFeature = @@ -376,7 +401,7 @@ std::shared_ptr compositeFeature()->addFeature(SketchPlugin_Line::ID()); return LinePtr(new SketchAPI_Line(aFeature, theExternal)); } -std::shared_ptr SketchAPI_Sketch::addLine(const std::string & theExternalName) +std::shared_ptr SketchAPI_Sketch::addLine(const std::wstring & theExternalName) { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Line::ID()); @@ -400,6 +425,49 @@ std::shared_ptr SketchAPI_Sketch::addRectangle( return RectanglePtr(new SketchAPI_Rectangle(aFeature, theStartPoint, theEndPoint)); } +static std::shared_ptr pointCoordinates( + const std::pair, ModelHighAPI_RefAttr> & thePoint) +{ + if (thePoint.first) + return thePoint.first; + + AttributePtr anAttr = thePoint.second.attr(); + if (thePoint.second.object()) { + FeaturePtr aFeature = ModelAPI_Feature::feature(thePoint.second.object()); + if (aFeature) + anAttr = aFeature->attribute(SketchPlugin_Point::COORD_ID()); + } + + std::shared_ptr aPntAttr = + std::dynamic_pointer_cast(anAttr); + if (aPntAttr) + return aPntAttr->pnt(); + return std::shared_ptr(); +} + +std::shared_ptr SketchAPI_Sketch::addRectangleCentered( + const std::pair, ModelHighAPI_RefAttr> & theCenter, + const std::pair, ModelHighAPI_RefAttr> & theCorner) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchAPI_Rectangle::ID()); + RectanglePtr aRect(new SketchAPI_Rectangle(aFeature)); + fillAttribute("RectangleTypeCentered", aRect->type()); + if (!theCenter.second.isEmpty()) + fillAttribute(theCenter.second, aRect->centerPointRef()); + fillAttribute(pointCoordinates(theCenter), aRect->centerPoint()); + fillAttribute(pointCoordinates(theCorner), aRect->cornerPoint()); + aRect->execute(); + + if (!theCorner.second.isEmpty() && aRect->linesList()->size() > 1) { + // get start point of the last line in rectangle and apply coindidence constraint + FeaturePtr aLine = ModelAPI_Feature::feature(aRect->linesList()->object(3)); + AttributePtr aEndPnt = aLine->attribute(SketchPlugin_Line::START_ID()); + setCoincident(ModelHighAPI_RefAttr(aEndPnt), theCorner.second); + } + return aRect; +} + //-------------------------------------------------------------------------------------- std::shared_ptr SketchAPI_Sketch::addCircle(double theCenterX, double theCenterY, @@ -468,7 +536,7 @@ std::shared_ptr return CirclePtr(new SketchAPI_Circle(aFeature, theExternal)); } -std::shared_ptr SketchAPI_Sketch::addCircle(const std::string & theExternalName) +std::shared_ptr SketchAPI_Sketch::addCircle(const std::wstring & theExternalName) { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Circle::ID()); @@ -562,7 +630,7 @@ std::shared_ptr SketchAPI_Sketch::addArc(const ModelHighAPI_Selec return ArcPtr(new SketchAPI_Arc(aFeature, theExternal)); } -std::shared_ptr SketchAPI_Sketch::addArc(const std::string & theExternalName) +std::shared_ptr SketchAPI_Sketch::addArc(const std::wstring & theExternalName) { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Arc::ID()); @@ -604,9 +672,9 @@ std::shared_ptr SketchAPI_Sketch::addEllipse( } std::shared_ptr SketchAPI_Sketch::addEllipse( - const std::pair, ModelHighAPI_RefAttr>& thePoint1, - const std::pair, ModelHighAPI_RefAttr>& thePoint2, - const std::pair, ModelHighAPI_RefAttr>& thePassedPoint, + const PointOrReference& thePoint1, + const PointOrReference& thePoint2, + const PointOrReference& thePassedPoint, bool isPoint1Center) { std::shared_ptr aFeature = @@ -637,7 +705,7 @@ std::shared_ptr SketchAPI_Sketch::addEllipse( } std::shared_ptr SketchAPI_Sketch::addEllipse( - const std::string & theExternalName) + const std::wstring & theExternalName) { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Ellipse::ID()); @@ -663,10 +731,10 @@ std::shared_ptr SketchAPI_Sketch::addEllipticArc( } std::shared_ptr SketchAPI_Sketch::addEllipticArc( - const std::pair, ModelHighAPI_RefAttr>& theCenter, - const std::pair, ModelHighAPI_RefAttr>& theMajorAxisPoint, - const std::pair, ModelHighAPI_RefAttr>& theStartPoint, - const std::pair, ModelHighAPI_RefAttr>& theEndPoint, + const PointOrReference& theCenter, + const PointOrReference& theMajorAxisPoint, + const PointOrReference& theStartPoint, + const PointOrReference& theEndPoint, bool theInversed) { std::shared_ptr aFeature = @@ -688,7 +756,7 @@ std::shared_ptr SketchAPI_Sketch::addEllipticArc( } std::shared_ptr SketchAPI_Sketch::addEllipticArc( - const std::string & theExternalName) + const std::wstring & theExternalName) { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_EllipticArc::ID()); @@ -696,25 +764,155 @@ std::shared_ptr SketchAPI_Sketch::addEllipticArc( } //-------------------------------------------------------------------------------------- -std::shared_ptr SketchAPI_Sketch::addProjection( - const ModelHighAPI_Selection & theExternalFeature, - bool theKeepResult) + +std::shared_ptr SketchAPI_Sketch::addSpline( + const ModelHighAPI_Selection & external, + const int degree, + const std::list& poles, + const std::list& weights, + const std::list& knots, + const std::list& multiplicities, + const bool periodic) +{ + // split poles and references to other shapes + bool hasReference = false; + std::list aPoints; + std::list aReferences; + for (std::list::const_iterator it = poles.begin(); it != poles.end(); ++it) { + aPoints.push_back(it->first); + aReferences.push_back(it->second); + if (!it->second.isEmpty()) + hasReference = true; + } + + BSplinePtr aBSpline; + CompositeFeaturePtr aSketch = compositeFeature(); + if (hasReference) { + // use macro-feature to create coincidences to referred features + FeaturePtr aMacroFeature = aSketch->addFeature( + periodic ? SketchPlugin_MacroBSplinePeriodic::ID() : SketchPlugin_MacroBSpline::ID()); + AttributePoint2DArrayPtr aPolesAttr = std::dynamic_pointer_cast( + aMacroFeature->attribute(SketchPlugin_MacroBSpline::POLES_ID())); + AttributeDoubleArrayPtr aWeightsAttr = + aMacroFeature->data()->realArray(SketchPlugin_MacroBSpline::WEIGHTS_ID()); + AttributeRefAttrListPtr aPolesRefAttr = + aMacroFeature->data()->refattrlist(SketchPlugin_MacroBSpline::REF_POLES_ID()); + // always generate a control polygon to apply coincidences correctly + aMacroFeature->boolean(SketchPlugin_MacroBSpline::CONTROL_POLYGON_ID())->setValue(true); + // initialize B-spline attributes + fillAttribute(aPoints, aPolesAttr); + if (weights.empty()) + fillAttribute(std::list(poles.size(), 1.0), aWeightsAttr); + else + fillAttribute(weights, aWeightsAttr); + fillAttribute(aReferences, aPolesRefAttr); + apply(); // to kill macro-feature + + // find created B-spline feature + const std::string& aKindToFind = + periodic ? SketchPlugin_BSplinePeriodic::ID() : SketchPlugin_BSpline::ID(); + int aNbSubs = aSketch->numberOfSubs(); + for (int anIndex = aNbSubs - 1; anIndex >= 0; --anIndex) { + FeaturePtr aFeature = aSketch->subFeature(anIndex); + if (aFeature->getKind() == aKindToFind) { + aBSpline.reset(periodic ? new SketchAPI_BSplinePeriodic(aFeature) + : new SketchAPI_BSpline(aFeature)); + aBSpline->execute(); + break; + } + } + } + else { + // compute B-spline by parameters + FeaturePtr aFeature = aSketch->addFeature( + periodic ? SketchPlugin_BSplinePeriodic::ID() : SketchPlugin_BSpline::ID()); + + aBSpline.reset(periodic ? new SketchAPI_BSplinePeriodic(aFeature) + : new SketchAPI_BSpline(aFeature)); + if (external.variantType() != ModelHighAPI_Selection::VT_Empty) + aBSpline->setByExternal(external); + else if (knots.empty() || multiplicities.empty()) + aBSpline->setByDegreePolesAndWeights(degree, aPoints, weights); + else + aBSpline->setByParameters(degree, aPoints, weights, knots, multiplicities); + } + return aBSpline; +} + +//-------------------------------------------------------------------------------------- +static std::shared_ptr buildInterpolation( + const CompositeFeaturePtr& theSketch, + const FeaturePtr& theCurveFittingFeature, + const std::list& points, + const bool periodic, + const bool closed) +{ + AttributeBooleanPtr aPeriodicAttr = + theCurveFittingFeature->boolean(SketchPlugin_CurveFitting::PERIODIC_ID()); + fillAttribute(periodic, aPeriodicAttr); + AttributeBooleanPtr aClosedAttr = + theCurveFittingFeature->boolean(SketchPlugin_CurveFitting::CLOSED_ID()); + fillAttribute(closed, aClosedAttr); + AttributeRefAttrListPtr aPointsAttr = + theCurveFittingFeature->refattrlist(SketchPlugin_CurveFitting::POINTS_ID()); + fillAttribute(points, aPointsAttr); + apply(); // to execute and kill the macro-feature + + // find created B-spline feature + BSplinePtr aBSpline; + const std::string& aKindToFind = + periodic ? SketchPlugin_BSplinePeriodic::ID() : SketchPlugin_BSpline::ID(); + int aNbSubs = theSketch->numberOfSubs(); + for (int anIndex = aNbSubs - 1; anIndex >= 0; --anIndex) { + FeaturePtr aFeature = theSketch->subFeature(anIndex); + if (aFeature->getKind() == aKindToFind) { + aBSpline.reset(periodic ? new SketchAPI_BSplinePeriodic(aFeature) + : new SketchAPI_BSpline(aFeature)); + aBSpline->execute(); + break; + } + } + return aBSpline; +} + +std::shared_ptr SketchAPI_Sketch::addInterpolation( + const std::list& points, + const bool periodic, + const bool closed) { - std::shared_ptr aFeature = - compositeFeature()->addFeature(SketchPlugin_Projection::ID()); - ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalFeature)); - aProjection->setIncludeToResult(theKeepResult); - return aProjection; + CompositeFeaturePtr aSketch = compositeFeature(); + FeaturePtr anInterpFeature = aSketch->addFeature(SketchPlugin_CurveFitting::ID()); + anInterpFeature->string(SketchPlugin_CurveFitting::TYPE_ID()) + ->setValue(SketchPlugin_CurveFitting::TYPE_INTERPOLATION_ID()); + return buildInterpolation(aSketch, anInterpFeature, points, periodic, closed); +} + +std::shared_ptr SketchAPI_Sketch::addApproximation( + const std::list& points, + const ModelHighAPI_Double& precision, + const bool periodic, + const bool closed) +{ + CompositeFeaturePtr aSketch = compositeFeature(); + FeaturePtr anInterpFeature = aSketch->addFeature(SketchPlugin_CurveFitting::ID()); + anInterpFeature->string(SketchPlugin_CurveFitting::TYPE_ID()) + ->setValue(SketchPlugin_CurveFitting::TYPE_APPROXIMATION_ID()); + fillAttribute(precision, anInterpFeature->real(SketchPlugin_CurveFitting::PRECISION_ID())); + return buildInterpolation(aSketch, anInterpFeature, points, periodic, closed); } +//-------------------------------------------------------------------------------------- std::shared_ptr SketchAPI_Sketch::addProjection( - const std::string & theExternalName, - bool theKeepResult) + const ModelHighAPI_Selection & theExternalFeature, + bool keepResult, + bool keepRefToOriginal) { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Projection::ID()); - ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalName)); - aProjection->setIncludeToResult(theKeepResult); + ProjectionPtr aProjection(new SketchAPI_Projection(aFeature)); + aProjection->setIncludeToResult(keepResult); + aProjection->setKeepReferenceToOriginal(keepRefToOriginal); + aProjection->setExternalFeature(theExternalFeature); return aProjection; } @@ -728,6 +926,18 @@ std::shared_ptr SketchAPI_Sketch::addMirror( return MirrorPtr(new SketchAPI_Mirror(aFeature, theMirrorLine, theObjects)); } +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addOffset( + const std::list > & theObjects, + const ModelHighAPI_Double & theValue, + const bool theReversed, + const std::string & theJointType) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_Offset::ID()); + return OffsetPtr(new SketchAPI_Offset(aFeature, theObjects, theValue, theReversed, theJointType)); +} + //-------------------------------------------------------------------------------------- std::shared_ptr SketchAPI_Sketch::addTranslation( const std::list > & theObjects, @@ -798,16 +1008,39 @@ std::shared_ptr SketchAPI_Sketch::addTrim( std::shared_ptr SketchAPI_Sketch::setAngle( const ModelHighAPI_RefAttr & theLine1, const ModelHighAPI_RefAttr & theLine2, - const ModelHighAPI_Double & theValue) + const ModelHighAPI_Double & theValue, + const std::string& theType) { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID()); - fillAttribute(SketcherPrs_Tools::ANGLE_DIRECT, - aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID())); - // fill the value before llines to avoid calculation of angle value by the Angle feature + + const int aVersion = theType.empty() ? SketchPlugin_ConstraintAngle::THE_VERSION_0 + : SketchPlugin_ConstraintAngle::THE_VERSION_1; + fillAttribute(aVersion, aFeature->integer(SketchPlugin_ConstraintAngle::VERSION_ID())); + + int aType = (int)SketcherPrs_Tools::ANGLE_DIRECT; + fillAttribute(aType, aFeature->integer(SketchPlugin_ConstraintAngle::PREV_TYPE_ID())); + fillAttribute(aType, aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID())); + + if (aVersion == SketchPlugin_ConstraintAngle::THE_VERSION_0) + fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); + fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); - fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); + + if (aVersion == SketchPlugin_ConstraintAngle::THE_VERSION_1) { + std::string aTypeLC = theType; + std::transform(aTypeLC.begin(), aTypeLC.end(), aTypeLC.begin(), + [](char c) { return static_cast(::tolower(c)); }); + if (aTypeLC == "supplementary") + aType = (int)SketcherPrs_Tools::ANGLE_COMPLEMENTARY; + else if (aTypeLC == "backward") + aType = (int)SketcherPrs_Tools::ANGLE_BACKWARD; + + fillAttribute(aType, aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID())); + fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); + } + aFeature->execute(); return InterfacePtr(new ModelHighAPI_Interface(aFeature)); } @@ -819,11 +1052,13 @@ std::shared_ptr SketchAPI_Sketch::setAngleComplementary( { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID()); + fillAttribute(SketchPlugin_ConstraintAngle::THE_VERSION_0, + aFeature->integer(SketchPlugin_ConstraintAngle::VERSION_ID())); fillAttribute(SketcherPrs_Tools::ANGLE_COMPLEMENTARY, aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID())); + fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); - fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); aFeature->execute(); return InterfacePtr(new ModelHighAPI_Interface(aFeature)); } @@ -835,11 +1070,13 @@ std::shared_ptr SketchAPI_Sketch::setAngleBackward( { std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID()); + fillAttribute(SketchPlugin_ConstraintAngle::THE_VERSION_0, + aFeature->integer(SketchPlugin_ConstraintAngle::VERSION_ID())); fillAttribute(SketcherPrs_Tools::ANGLE_BACKWARD, aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID())); + fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); - fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); aFeature->execute(); return InterfacePtr(new ModelHighAPI_Interface(aFeature)); } @@ -1156,7 +1393,16 @@ static std::shared_ptr pointOnEllipse(const FeaturePtr& theFeatur return aMajorAxisEnd ? aMajorAxisEnd->pnt() : std::shared_ptr(); } -static std::shared_ptr middlePoint(const ObjectPtr& theObject) +static std::shared_ptr middlePointOnBSpline(const FeaturePtr& theFeature, + SketchAPI_Sketch* theSketch) +{ + GeomAPI_Edge anEdge(theFeature->lastResult()->shape()); + GeomPointPtr aMiddle = anEdge.middlePoint(); + return theSketch->to2D(aMiddle); +} + +static std::shared_ptr middlePoint(const ObjectPtr& theObject, + SketchAPI_Sketch* theSketch) { std::shared_ptr aMiddlePoint; FeaturePtr aFeature = ModelAPI_Feature::feature(theObject); @@ -1175,6 +1421,9 @@ static std::shared_ptr middlePoint(const ObjectPtr& theObject) aMiddlePoint = pointOnEllipse(aFeature); else if (aFeatureKind == SketchPlugin_EllipticArc::ID()) aMiddlePoint = pointOnEllipse(aFeature, false); + else if (aFeatureKind == SketchPlugin_BSpline::ID() || + aFeatureKind == SketchPlugin_BSplinePeriodic::ID()) + aMiddlePoint = middlePointOnBSpline(aFeature, theSketch); } return aMiddlePoint; } @@ -1189,7 +1438,7 @@ void SketchAPI_Sketch::move(const ModelHighAPI_RefAttr& theMovedEntity, if (aMessage->movedAttribute()) anOriginalPosition = pointCoordinates(aMessage->movedAttribute()); else - anOriginalPosition = middlePoint(aMessage->movedObject()); + anOriginalPosition = middlePoint(aMessage->movedObject(), this); if (!anOriginalPosition) return; // something has gone wrong, do not process movement @@ -1336,7 +1585,7 @@ void SketchAPI_Sketch::dump(ModelHighAPI_Dumper& theDumper) const aBase->attribute(SketchPlugin_Sketch::DIRX_ID()))->dir(); // Check the plane is coordinate plane - std::string aPlaneName = defaultPlane(anOrigin, aNormal, aDirX); + std::wstring aPlaneName = defaultPlane(anOrigin, aNormal, aDirX); if(anExternal->context()) { // checking for selected planes if (!aPlaneName.empty() && anExternal->context()->data() @@ -1395,5 +1644,7 @@ void SketchAPI_Sketch::dump(ModelHighAPI_Dumper& theDumper) const theDumper << *aFIt; } theDumper << "\n" << aSpaceShift << " ])" << std::endl; + // call model.do() for correct update of the document's labels related to the changed faces + theDumper << "model.do()" << std::endl; } }