Trim Circle feature, Line and Arc features.
#include "GeomAPI_Shape.h"
#include <BRep_Tool.hxx>
-#include <BRepAlgoAPI_Common.hxx>
+#include <BRepAlgoAPI_Section.hxx>
#include <BRepBndLib.hxx>
#include <BRepBuilderAPI_FindPlane.hxx>
#include <BRepTools.hxx>
const TopoDS_Shape& aShape1 = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
const TopoDS_Shape& aShape2 = theShape->impl<TopoDS_Shape>();
- BRepAlgoAPI_Common aCommon(aShape1, aShape2);
+ BRepAlgoAPI_Section aCommon(aShape1, aShape2);
if (!aCommon.IsDone())
return GeomShapePtr();
//==================================================================================================
void GeomAlgoAPI_ShapeTools::splitShape(const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
+ const GeomAlgoAPI_ShapeTools::PointToRefsMap& thePointsInfo,
+ std::set<std::shared_ptr<GeomAPI_Shape> >& theShapes)
+{
+ // General Fuse to split edge by vertices
+ BOPAlgo_Builder aBOP;
+ TopoDS_Edge aBaseEdge = theBaseShape->impl<TopoDS_Edge>();
+ // Rebuild closed edge to place vertex to one of split points.
+ // This will prevent edge to be split on same vertex.
+ if (BRep_Tool::IsClosed(aBaseEdge))
+ {
+ Standard_Real aFirst, aLast;
+ Handle(Geom_Curve) aCurve = BRep_Tool::Curve(aBaseEdge, aFirst, aLast);
+
+ PointToRefsMap::const_iterator aPIt = thePointsInfo.begin();
+ std::shared_ptr<GeomAPI_Pnt> aPnt = aPIt->first;
+ gp_Pnt aPoint(aPnt->x(), aPnt->y(), aPnt->z());
+
+ TopAbs_Orientation anOrientation = aBaseEdge.Orientation();
+ aBaseEdge = BRepBuilderAPI_MakeEdge(aCurve, aPoint, aPoint).Edge();
+ aBaseEdge.Orientation(anOrientation);
+ }
+ aBOP.AddArgument(aBaseEdge);
+
+ //std::list<std::shared_ptr<GeomAPI_Pnt> >::const_iterator aPtIt = thePoints.begin();
+ PointToRefsMap::const_iterator aPIt = thePointsInfo.begin();
+ for (; aPIt != thePointsInfo.end(); ++aPIt) {
+ std::shared_ptr<GeomAPI_Pnt> aPnt = aPIt->first;
+ TopoDS_Vertex aV = BRepBuilderAPI_MakeVertex(gp_Pnt(aPnt->x(), aPnt->y(), aPnt->z()));
+ aBOP.AddArgument(aV);
+ }
+
+ aBOP.Perform();
+ if (aBOP.ErrorStatus())
+ return;
+
+ // Collect splits
+ const TopTools_ListOfShape& aSplits = aBOP.Modified(aBaseEdge);
+ TopTools_ListIteratorOfListOfShape anIt(aSplits);
+ for (; anIt.More(); anIt.Next()) {
+ std::shared_ptr<GeomAPI_Shape> anEdge(new GeomAPI_Shape);
+ anEdge->setImpl(new TopoDS_Shape(anIt.Value()));
+ theShapes.insert(anEdge);
+ }
+}
+
+//==================================================================================================
+void GeomAlgoAPI_ShapeTools::splitShape_p(const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
const std::list<std::shared_ptr<GeomAPI_Pnt> >& thePoints,
std::set<std::shared_ptr<GeomAPI_Shape> >& theShapes)
{
#include <GeomAPI_Shape.h>
#include <GeomAPI_Vertex.h>
+#include <map>
#include <set>
class GeomAPI_Edge;
class GeomAPI_PlanarEdges;
class GeomAPI_Pln;
class GeomAPI_Pnt;
+class GeomDataAPI_Point2D;
+class ModelAPI_Object;
/// \class GeomAlgoAPI_ShapeTools
/// \ingroup DataAlgo
GEOMALGOAPI_EXPORT static bool isParallel(const std::shared_ptr<GeomAPI_Edge> theEdge,
const std::shared_ptr<GeomAPI_Face> theFace);
+ typedef std::map<std::shared_ptr<GeomAPI_Pnt>,
+ std::pair<std::list<std::shared_ptr<GeomDataAPI_Point2D> >,
+ std::list<std::shared_ptr<ModelAPI_Object> > > > PointToRefsMap;
/// \brief Performs the split of the shape by points.
/// \param[in] theBaseShape shape that should be splitted.
/// \param[in] thePoints container of points to split
/// \param[out] theShapes container of shapes after split
GEOMALGOAPI_EXPORT static void splitShape(const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
- const std::list<std::shared_ptr<GeomAPI_Pnt> >& thePoints,
+ const PointToRefsMap& thePointsInfo,
std::set<std::shared_ptr<GeomAPI_Shape> >& theShapes);
+ /// \brief Performs the split of the shape by points.
+ /// \param[in] theBaseShape shape that should be splitted.
+ /// \param[in] thePoints container of points to split
+ /// \param[out] theShapes container of shapes after split
+ GEOMALGOAPI_EXPORT static void splitShape_p(const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
+ const std::list<std::shared_ptr<GeomAPI_Pnt> >& thePoints,
+ std::set<std::shared_ptr<GeomAPI_Shape> >& theShapes);
GEOMALGOAPI_EXPORT static std::shared_ptr<GeomAPI_Shape> findShape(
const std::list<std::shared_ptr<GeomAPI_Pnt> >& thePoints,
void shapesOfType(const FeaturePtr& theFeature,
const GeomAPI_Shape::ShapeType& theType,
- std::set<GeomShapePtr>& theShapes)
+ std::set<ResultPtr>& theShapeResults)
{
+ theShapeResults.clear();
std::list<ResultPtr> aResults = theFeature->results();
std::list<ResultPtr>::const_iterator aRIter = aResults.cbegin();
for (; aRIter != aResults.cend(); aRIter++) {
ResultPtr aResult = *aRIter;
GeomShapePtr aShape = aResult->shape();
if (aShape.get() && aShape->shapeType() == theType)
- theShapes.insert(aShape);
+ theShapeResults.insert(aResult);
}
}
/// Creates a container of shape of the feature results satisfied the given shape type
/// \param theFeature a source feature
/// \param theType shape type
-/// \param an output container for shapes
+/// \param an output container for result of shapes
MODELAPI_EXPORT void shapesOfType(const FeaturePtr& theFeature,
const GeomAPI_Shape::ShapeType& theType,
- std::set<GeomShapePtr>& theShapes);
+ std::set<ResultPtr>& theShapeResults);
/*! Returns the feature error generated according to feature error and exec state
* \param theFeature a feature
#include <ModelAPI_Feature.h>
#include <ModelAPI_Result.h>
#include <ModelAPI_AttributeRefAttr.h>
+#include <ModelAPI_CompositeFeature.h>
+#include <ModelAPI_Tools.h>
+
+#include <GeomAPI_ShapeIterator.h>
#include <GeomAlgoAPI_ShapeTools.h>
#include <GeomDataAPI_Point2D.h>
}
}
+ void appendPoint(const std::shared_ptr<GeomAPI_Pnt>& thePoint,
+ const std::shared_ptr<ModelAPI_Result>& theResult,
+ PointToRefsMap& thePointToAttributeOrObject)
+ {
+ if (thePointToAttributeOrObject.find(thePoint) != thePointToAttributeOrObject.end())
+ thePointToAttributeOrObject.at(thePoint).second.push_back(theResult);
+ else {
+ std::list<std::shared_ptr<GeomDataAPI_Point2D> > anAttributes;
+ std::list<std::shared_ptr<ModelAPI_Object> > anObjects;
+ anObjects.push_back(theResult);
+ thePointToAttributeOrObject[thePoint] = std::make_pair(anAttributes, anObjects);
+ }
+ }
+
+ void appendShapePoints(GeomShapePtr& theShape,
+ const std::shared_ptr<ModelAPI_Result>& theResult,
+ PointToRefsMap& thePointToAttributeOrObject)
+ {
+ if (!theShape.get())
+ return;
+
+ switch (theShape->shapeType()) {
+ case GeomAPI_Shape::VERTEX: {
+ std::shared_ptr<GeomAPI_Vertex> aVertex =
+ std::shared_ptr<GeomAPI_Vertex>(new GeomAPI_Vertex(theShape));
+ std::shared_ptr<GeomAPI_Pnt> aPnt = aVertex->point();
+ appendPoint(aPnt, theResult, thePointToAttributeOrObject);
+ }
+ break;
+ case GeomAPI_Shape::EDGE: {
+ std::shared_ptr<GeomAPI_Edge> anEdge =
+ std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(theShape));
+ appendPoint(anEdge->firstPoint(), theResult, thePointToAttributeOrObject);
+ appendPoint(anEdge->lastPoint(), theResult, thePointToAttributeOrObject);
+ }
+ break;
+ case GeomAPI_Shape::COMPOUND: {
+ for(GeomAPI_ShapeIterator anIt(theShape); anIt.more(); anIt.next()) {
+ appendShapePoints(anIt.current(), theResult, thePointToAttributeOrObject);
+ }
+ }
+ break;
+ default: break;
+ }
+ }
+
+ void getPointsIntersectedShape(const std::shared_ptr<ModelAPI_Feature>& theBaseFeature,
+ const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
+ PointToRefsMap& thePointToAttributeOrObject)
+ {
+ GeomShapePtr aFeatureShape;
+ {
+ std::set<ResultPtr> anEdgeShapes;
+ ModelAPI_Tools::shapesOfType(theBaseFeature, GeomAPI_Shape::EDGE, anEdgeShapes);
+ if (anEdgeShapes.empty())
+ return;
+ aFeatureShape = (*anEdgeShapes.begin())->shape();
+ }
+
+ std::list<std::shared_ptr<ModelAPI_Feature> >::const_iterator anIt = theFeatures.begin(),
+ aLast = theFeatures.end();
+ for (; anIt != aLast; anIt++) {
+ FeaturePtr aFeature = *anIt;
+ if (aFeature.get() == theBaseFeature.get())
+ continue;
+ if (aFeature.get()) {
+ std::set<ResultPtr> anEdgeShapes;
+ ModelAPI_Tools::shapesOfType(aFeature, GeomAPI_Shape::EDGE, anEdgeShapes);
+ if (anEdgeShapes.empty())
+ continue;
+ ResultPtr aResult = *anEdgeShapes.begin();
+ GeomShapePtr aShape = aResult->shape();
+
+ GeomShapePtr aShapeOfIntersection = aFeatureShape->intersect(aShape);
+ appendShapePoints(aShapeOfIntersection, aResult, thePointToAttributeOrObject);
+ }
+ }
+ }
+
void getPointsInsideShape(const std::shared_ptr<GeomAPI_Shape> theBaseShape,
+ const std::set<std::shared_ptr<GeomDataAPI_Point2D> >& theAttributes,
+ const std::shared_ptr<GeomAPI_Pnt>& theOrigin,
+ const std::shared_ptr<GeomAPI_Dir>& theDirX,
+ const std::shared_ptr<GeomAPI_Dir>& theDirY,
+ PointToRefsMap& thePointToAttributeOrObject)
+ {
+ std::set<std::shared_ptr<GeomDataAPI_Point2D> >::const_iterator anIt = theAttributes.begin(),
+ aLast = theAttributes.end();
+ for (; anIt != aLast; anIt++) {
+ std::shared_ptr<GeomDataAPI_Point2D> anAttribute = *anIt;
+ std::shared_ptr<GeomAPI_Pnt2d> aPnt2d = anAttribute->pnt();
+ std::shared_ptr<GeomAPI_Pnt> aPoint = aPnt2d->to3D(theOrigin, theDirX, theDirY);
+ std::shared_ptr<GeomAPI_Pnt> aProjectedPoint;
+ if (isPointOnEdge(theBaseShape, aPoint, aProjectedPoint)) {
+ if (thePointToAttributeOrObject.find(aProjectedPoint) != thePointToAttributeOrObject.end())
+ thePointToAttributeOrObject.at(aProjectedPoint).first.push_back(anAttribute);
+ else {
+ //std::list< std::shared_ptr<GeomDataAPI_Point2D> > anAttributes;
+ //anAttributes.push_back(anAttribute);
+ //thePointToAttributeOrObject.insert(aProjectedPoint, anAttributes);
+
+ std::list<std::shared_ptr<GeomDataAPI_Point2D> > anAttributes;
+ std::list<std::shared_ptr<ModelAPI_Object> > anObjects;
+ anAttributes.push_back(anAttribute);
+ thePointToAttributeOrObject[aProjectedPoint] = std::make_pair(anAttributes, anObjects);
+ }
+ //thePoints.push_back(aProjectedPoint);
+ //theAttributeToPoint[anAttribute] = aProjectedPoint;
+ }
+ }
+ }
+
+ void getPointsInsideShape_p(const std::shared_ptr<GeomAPI_Shape> theBaseShape,
const std::set<std::shared_ptr<GeomDataAPI_Point2D> >& theAttributes,
const std::shared_ptr<GeomAPI_Pnt>& theOrigin,
const std::shared_ptr<GeomAPI_Dir>& theDirX,
const std::string& theObjectFeatureAttribute = "",
const bool isSkipFeatureAttributes = true);
+ /// Find points of intersection between the shape of the feature and all features in the sketch
+ /// \param theBaseFeature a feature: line, arc or circle that will be intersected
+ /// \param theFeatures a container of features to intersect with the base feature
+ /// \param thePoints a container of 3D points belong to the shape
+ /// \param theObjectToPoint a container of object to point
+ typedef std::map<std::shared_ptr<GeomAPI_Pnt>,
+ std::pair<std::list<std::shared_ptr<GeomDataAPI_Point2D> >,
+ std::list<std::shared_ptr<ModelAPI_Object> > > > PointToRefsMap;
+
+ MODELGEOMALGO_EXPORT void getPointsIntersectedShape(
+ const std::shared_ptr<ModelAPI_Feature>& theBaseFeature,
+ const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
+ PointToRefsMap& thePointToAttributeOrObject);
+
/// Removes attributes which points are out of the base shape
/// \param theBaseShape a shape of check
/// \param theAttributes a container of point 2D attributes
/// \param theDirX plane X direction to generate 3D point by 2D attribute point
/// \param theDirY plane X direction to generate 3D point by 2D attribute point
/// \param thePoints a container of 3D points belong to the shape
+ /// \param theAttributeToPoint a container of attribute to point
MODELGEOMALGO_EXPORT void getPointsInsideShape(
+ const std::shared_ptr<GeomAPI_Shape> theBaseShape,
+ const std::set<std::shared_ptr<GeomDataAPI_Point2D> >& theAttributes,
+ const std::shared_ptr<GeomAPI_Pnt>& theOrigin,
+ const std::shared_ptr<GeomAPI_Dir>& theDirX,
+ const std::shared_ptr<GeomAPI_Dir>& theDirY,
+ PointToRefsMap& thePointToAttributeOrObject);
+
+ /// Removes attributes which points are out of the base shape
+ /// \param theBaseShape a shape of check
+ /// \param theAttributes a container of point 2D attributes
+ /// \param theOrigin origin of a plane to generate 3D point by 2D attribute point
+ /// \param theDirX plane X direction to generate 3D point by 2D attribute point
+ /// \param theDirY plane X direction to generate 3D point by 2D attribute point
+ /// \param thePoints a container of 3D points belong to the shape
+ /// \param theAttributeToPoint a container of attribute to point
+ MODELGEOMALGO_EXPORT void getPointsInsideShape_p(
const std::shared_ptr<GeomAPI_Shape> theBaseShape,
const std::set<std::shared_ptr<GeomDataAPI_Point2D> >& theAttributes,
const std::shared_ptr<GeomAPI_Pnt>& theOrigin,
PartSet_Constants.h
PartSet_CustomPrs.h
PartSet_ExternalObjectsMgr.h
+ PartSet_FilterInfinite.h
+ PartSet_Filters.h
+ PartSet_IconFactory.h
+ PartSet_MenuMgr.h
PartSet_Module.h
PartSet_MouseProcessor.h
PartSet_OperationPrs.h
PartSet_OverconstraintListener.h
PartSet_PreviewPlanes.h
+ PartSet_ResultSketchPrs.h
+ PartSet_SketcherMgr.h
+ PartSet_SketcherReetntrantMgr.h
PartSet_Tools.h
- PartSet_WidgetSketchLabel.h
PartSet_Validators.h
- PartSet_WidgetPoint2d.h
+ PartSet_WidgetChoice.h
PartSet_WidgetEditor.h
+ PartSet_WidgetFeaturePointSelector.h
+ PartSet_WidgetFileSelector.h
PartSet_WidgetMultiSelector.h
+ PartSet_WidgetPoint2d.h
PartSet_WidgetPoint2dDistance.h
PartSet_WidgetPoint2DFlyout.h
PartSet_WidgetShapeSelector.h
- PartSet_WidgetFileSelector.h
- PartSet_Filters.h
- PartSet_FilterInfinite.h
- PartSet_ResultSketchPrs.h
- PartSet_SketcherMgr.h
- PartSet_SketcherReetntrantMgr.h
- PartSet_MenuMgr.h
PartSet_WidgetSketchCreator.h
- PartSet_IconFactory.h
- PartSet_WidgetChoice.h
+ PartSet_WidgetSketchLabel.h
PartSet_WidgetSubShapeSelector.h
)
SET(PROJECT_MOC_HEADERS
+
PartSet_MenuMgr.h
PartSet_Module.h
PartSet_SketcherMgr.h
PartSet_SketcherReetntrantMgr.h
PartSet_WidgetChoice.h
PartSet_WidgetEditor.h
+ PartSet_WidgetFeaturePointSelector.h
PartSet_WidgetFileSelector.h
PartSet_WidgetMultiSelector.h
PartSet_WidgetPoint2d.h
SET(PROJECT_SOURCES
PartSet_CustomPrs.cpp
PartSet_ExternalObjectsMgr.cpp
+ PartSet_FilterInfinite.cpp
+ PartSet_Filters.cpp
+ PartSet_IconFactory.cpp
+ PartSet_MenuMgr.cpp
PartSet_Module.cpp
PartSet_OperationPrs.cpp
PartSet_OverconstraintListener.cpp
PartSet_PreviewPlanes.cpp
+ PartSet_ResultSketchPrs.cpp
+ PartSet_SketcherMgr.cpp
+ PartSet_SketcherReetntrantMgr.cpp
PartSet_Tools.cpp
- PartSet_WidgetSketchLabel.cpp
PartSet_Validators.cpp
PartSet_WidgetEditor.cpp
+ PartSet_WidgetFeaturePointSelector.cpp
+ PartSet_WidgetFileSelector.cpp
PartSet_WidgetMultiSelector.cpp
PartSet_WidgetPoint2d.cpp
PartSet_WidgetPoint2dDistance.cpp
PartSet_WidgetPoint2DFlyout.cpp
PartSet_WidgetShapeSelector.cpp
- PartSet_WidgetFileSelector.cpp
- PartSet_Filters.cpp
- PartSet_FilterInfinite.cpp
- PartSet_ResultSketchPrs.cpp
- PartSet_SketcherMgr.cpp
- PartSet_SketcherReetntrantMgr.cpp
- PartSet_MenuMgr.cpp
PartSet_WidgetSketchCreator.cpp
- PartSet_IconFactory.cpp
+ PartSet_WidgetSketchLabel.cpp
PartSet_WidgetSubShapeSelector.cpp
)
#include "PartSet_WidgetShapeSelector.h"
#include "PartSet_WidgetMultiSelector.h"
#include "PartSet_WidgetSubShapeSelector.h"
+#include "PartSet_WidgetFeaturePointSelector.h"
#include "PartSet_WidgetEditor.h"
#include "PartSet_WidgetFileSelector.h"
#include "PartSet_WidgetSketchCreator.h"
aSubShapeSelectorWgt->setSketcher(mySketchMgr->activeSketch());
aWgt = aSubShapeSelectorWgt;
}
+ else if (theType == "sketch_feature_point_selector") {
+ PartSet_WidgetFeaturePointSelector* aPointSelectorWgt =
+ new PartSet_WidgetFeaturePointSelector(theParent, aWorkshop, theWidgetApi);
+ aPointSelectorWgt->setSketcher(mySketchMgr->activeSketch());
+ aWgt = aPointSelectorWgt;
+ }
else if (theType == WDG_DOUBLEVALUE_EDITOR) {
aWgt = new PartSet_WidgetEditor(theParent, aWorkshop, theWidgetApi);
} else if (theType == "export_file_selector") {
#include "PartSet.h"
+#include <memory>
+
class ModuleBase_IViewWindow;
+class ModuleBase_ViewerPrs;
class QMouseEvent;
/**
/// \param theEvent a mouse event
PARTSET_EXPORT virtual void mouseDoubleClick(ModuleBase_IViewWindow* theWindow,
QMouseEvent* theEvent) {}
+
+ /// Fill preselection used in mouseReleased
+ virtual void setPreSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& thePreSelected,
+ ModuleBase_IViewWindow* theWnd,
+ QMouseEvent* theEvent) {}
};
#endif
// fill the first widget by the mouse event point
// if the active widget is not the first, it means that the restarted operation is filled by
// the current preselection.
- PartSet_WidgetPoint2D* aPoint2DWdg =
- dynamic_cast<PartSet_WidgetPoint2D*>(module()->activeWidget());
- ModuleBase_ModelWidget* aFirstWidget = aPanel->findFirstAcceptingValueWidget();
- if (aPoint2DWdg && aPoint2DWdg == aFirstWidget) {
+ PartSet_MouseProcessor* aMouseProcessor = dynamic_cast<PartSet_MouseProcessor*>(
+ module()->activeWidget());
+ //PartSet_WidgetPoint2D* aPoint2DWdg =
+ // dynamic_cast<PartSet_WidgetPoint2D*>(module()->activeWidget());
+ PartSet_MouseProcessor* aFirstWidget = dynamic_cast<PartSet_MouseProcessor*>(
+ aPanel->findFirstAcceptingValueWidget());
+ //if (aPoint2DWdg && aPoint2DWdg == aFirstWidget) {
+ if (aMouseProcessor && aMouseProcessor == aFirstWidget) {
+ std::shared_ptr<ModuleBase_ViewerPrs> aSelectedPrs;
if (!aPreSelected.empty())
- aPoint2DWdg->setPreSelection(aPreSelected.front());
- aPoint2DWdg->mouseReleased(theWnd, theEvent);
- if (!aPreSelected.empty())
- aPoint2DWdg->setPreSelection(ModuleBase_ViewerPrsPtr());
+ aSelectedPrs = aPreSelected.front();
+ aMouseProcessor->setPreSelection(aSelectedPrs, theWnd, theEvent);
+ //aPoint2DWdg->mouseReleased(theWnd, theEvent);
+ //if (!aPreSelected.empty())
+ // aPoint2DWdg->setPreSelection(ModuleBase_ViewerPrsPtr());
}
// unblock viewer update
ModuleBase_Tools::blockUpdateViewer(false);
--- /dev/null
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
+
+// File: PartSet_WidgetFeaturePointSelector.cpp
+// Created: 28 Feb 2017
+// Author: Natalia ERMOLAEVA
+
+#include <Config_WidgetAPI.h>
+
+#include <Events_Loop.h>
+
+#include <GeomDataAPI_Point2D.h>
+#include <GeomDataAPI_Point.h>
+#include <GeomAPI_Edge.h>
+#include <GeomAPI_Pnt2d.h>
+#include <GeomAlgoAPI_ShapeTools.h>
+
+#include <ModuleBase_ISelection.h>
+#include <ModuleBase_ViewerPrs.h>
+
+#include <ModelAPI_Events.h>
+#include <ModelAPI_Feature.h>
+#include <ModelAPI_Tools.h>
+
+#include <ModuleBase_IViewWindow.h>
+#include <ModuleBase_IWorkshop.h>
+#include <ModuleBase_IModule.h>
+#include <ModelGeomAlgo_Point2D.h>
+
+#include "PartSet_WidgetFeaturePointSelector.h"
+#include "PartSet_Tools.h"
+
+#include <SketchPlugin_ConstraintCoincidence.h>
+#include <SketchPlugin_Constraint.h>
+#include <SketchPlugin_Point.h>
+#include <SketchPlugin_Trim.h>
+
+#include <XGUI_Tools.h>
+#include <XGUI_Workshop.h>
+#include <XGUI_Displayer.h>
+#include <XGUI_ViewerProxy.h>
+
+#include <QWidget>
+#include <QMouseEvent>
+
+#define HIGHLIGHT_STAYS_PROBLEM
+#ifdef HIGHLIGHT_STAYS_PROBLEM
+#include <Quantity_Color.hxx>
+#define SKETCH_ENTITY_COLOR "225,0,0"
+#endif
+
+PartSet_WidgetFeaturePointSelector::PartSet_WidgetFeaturePointSelector(QWidget* theParent,
+ ModuleBase_IWorkshop* theWorkshop,
+ const Config_WidgetAPI* theData)
+: ModuleBase_WidgetShapeSelector(theParent, theWorkshop, theData)
+{
+ myUseGraphicIntersection = theData->getBooleanAttribute("use_graphic_intersection", false);
+ //myCurrentSubShape = std::shared_ptr<ModuleBase_ViewerPrs>(new ModuleBase_ViewerPrs());
+}
+
+PartSet_WidgetFeaturePointSelector::~PartSet_WidgetFeaturePointSelector()
+{
+ //myCashedShapes.clear();
+}
+
+//********************************************************************
+bool PartSet_WidgetFeaturePointSelector::isValidSelection(
+ const std::shared_ptr<ModuleBase_ViewerPrs>& theValue)
+{
+ return true;
+}
+
+//********************************************************************
+void PartSet_WidgetFeaturePointSelector::activateCustom()
+{
+ ModuleBase_WidgetShapeSelector::activateCustom();
+
+ myWorkshop->module()->activateCustomPrs(myFeature,
+ ModuleBase_IModule::CustomizeHighlightedObjects, true);
+
+ Handle(AIS_InteractiveContext) aContext =
+ XGUI_Tools::workshop(myWorkshop)->viewer()->AISContext();
+
+ std::vector<int> aColors;
+ aColors = Config_PropManager::color("Visualization", "sketch_entity_color",
+ SKETCH_ENTITY_COLOR);
+ Quantity_Color aColor(aColors[0] / 255., aColors[1] / 255., aColors[2] / 255., Quantity_TOC_RGB);
+
+#ifdef HIGHLIGHT_STAYS_PROBLEM
+ Handle(Graphic3d_HighlightStyle) aHStyle = aContext->HighlightStyle();
+ myHighlightColor = aHStyle->Color();
+ aHStyle->SetColor(aColor);
+ aContext->SetHighlightStyle(aHStyle);
+
+ Handle(Graphic3d_HighlightStyle) aSStyle = aContext->SelectionStyle();
+ mySelectionColor = aSStyle->Color();
+ aSStyle->SetColor(aColor);
+ aContext->SetSelectionStyle(aSStyle);
+#endif
+}
+
+//********************************************************************
+void PartSet_WidgetFeaturePointSelector::deactivate()
+{
+ ModuleBase_WidgetShapeSelector::deactivate();
+
+ Handle(AIS_InteractiveContext) aContext =
+ XGUI_Tools::workshop(myWorkshop)->viewer()->AISContext();
+
+#ifdef HIGHLIGHT_STAYS_PROBLEM
+ Handle(Graphic3d_HighlightStyle) aHStyle = aContext->HighlightStyle();
+ aHStyle->SetColor(myHighlightColor);
+ aContext->SetHighlightStyle(aHStyle);
+
+ Handle(Graphic3d_HighlightStyle) aSStyle = aContext->SelectionStyle();
+ aSStyle->SetColor(mySelectionColor);
+ aContext->SetSelectionStyle(aSStyle);
+#endif
+ //myWorkshop->module()->deactivateCustomPrs(ModuleBase_IModule::CustomizeHighlightedObjects, true);
+}
+
+//********************************************************************
+void PartSet_WidgetFeaturePointSelector::mouseMoved(ModuleBase_IViewWindow* theWindow,
+ QMouseEvent* theEvent)
+{
+ ModuleBase_ISelection* aSelect = myWorkshop->selection();
+ QList<ModuleBase_ViewerPrsPtr> aHighlighted = aSelect->getHighlighted();
+
+ if (!aHighlighted.empty()) {
+ ModuleBase_ViewerPrsPtr aPrs = aHighlighted.first();
+ fillFeature(aPrs, theWindow, theEvent);
+ }
+}
+
+//********************************************************************
+void PartSet_WidgetFeaturePointSelector::mouseReleased(ModuleBase_IViewWindow* theWindow,
+ QMouseEvent* theEvent)
+{
+ // the contex menu release by the right button should not be processed by this widget
+ if (theEvent->button() != Qt::LeftButton)
+ return;
+
+ emit focusOutWidget(this);
+}
+
+//********************************************************************
+bool PartSet_WidgetFeaturePointSelector::fillFeature(
+ const std::shared_ptr<ModuleBase_ViewerPrs>& theSelectedPrs,
+ ModuleBase_IViewWindow* theWindow,
+ QMouseEvent* theEvent)
+{
+ bool aFilled = false;
+ if (theSelectedPrs.get() && theSelectedPrs->object().get()) {
+ ObjectPtr anObject = theSelectedPrs->object();
+ //if (myCashedShapes.find(anObject) == myCashedShapes.end())
+ // fillObjectShapes(anObject);
+ //const std::set<GeomShapePtr>& aShapes = myCashedShapes[anObject];
+ //if (!aShapes.empty()) {
+ gp_Pnt aPnt = PartSet_Tools::convertClickToPoint(theEvent->pos(), theWindow->v3dView());
+ double aX, anY;
+ Handle(V3d_View) aView = theWindow->v3dView();
+ PartSet_Tools::convertTo2D(aPnt, mySketch, aView, aX, anY);
+ //std::shared_ptr<GeomAPI_Pnt> aPoint = PartSet_Tools::convertTo3D(aX, anY, mySketch);
+
+ std::shared_ptr<ModelAPI_AttributeReference> aRef =
+ std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ feature()->data()->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ aRef->setValue(anObject);
+
+ std::shared_ptr<GeomDataAPI_Point2D> anAttributePoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ feature()->data()->attribute(SketchPlugin_Trim::ENTITY_POINT()));
+ //std::shared_ptr<GeomAPI_Pnt2d> aPoint2D = anAttributePoint->pnt();
+ anAttributePoint->setValue(aX, anY);
+ // redisplay AIS presentation in viewer
+#ifndef HIGHLIGHT_STAYS_PROBLEM
+ // an attempt to clear highlighted item in the viewer: but of OCCT
+ XGUI_Tools::workshop(myWorkshop)->displayer()->clearSelected(true);
+#endif
+ updateObject(feature());
+ aFilled = true;
+
+ /*
+ std::set<GeomShapePtr>::const_iterator anIt = aShapes.begin(), aLast = aShapes.end();
+ for (; anIt != aLast; anIt++) {
+ GeomShapePtr aBaseShape = *anIt;
+ std::shared_ptr<GeomAPI_Pnt> aProjectedPoint;
+ if (ModelGeomAlgo_Point2D::isPointOnEdge(aBaseShape, aPoint, aProjectedPoint)) {
+ XGUI_Tools::workshop(myWorkshop)->displayer()->clearSelected(false);
+ if (myCurrentSubShape->object() != anObject ||
+ myCurrentSubShape->shape() != aBaseShape) {
+ myCurrentSubShape->setObject(anObject);
+ myCurrentSubShape->setShape(aBaseShape);
+
+ ModuleBase_IModule* aModule = myWorkshop->module();
+
+
+ if (!aModule->isCustomPrsActivated(ModuleBase_IModule::CustomizeHighlightedObjects))
+ aModule->activateCustomPrs(myFeature,
+ ModuleBase_IModule::CustomizeHighlightedObjects, true);
+ aModule->customizeObject(myFeature,
+ ModuleBase_IModule::CustomizeHighlightedObjects, true);
+ }
+ else
+ XGUI_Tools::workshop(myWorkshop)->displayer()->updateViewer();
+ break;
+ }
+ }*/
+ //}
+ //}
+ }
+ return aFilled;
+}
+
+//********************************************************************
+/*void PartSet_WidgetFeaturePointSelector::getGeomSelection(const ModuleBase_ViewerPrsPtr& thePrs,
+ ObjectPtr& theObject,
+ GeomShapePtr& theShape)
+{
+ ModuleBase_ISelection* aSelection = myWorkshop->selection();
+ theObject = aSelection->getResult(thePrs);
+ if (!theObject.get() && myCurrentSubShape->object())
+ theObject = myCurrentSubShape->object();
+}*/
+
+//********************************************************************
+QList<ModuleBase_ViewerPrsPtr> PartSet_WidgetFeaturePointSelector::getAttributeSelection() const
+{
+ return QList<ModuleBase_ViewerPrsPtr>();
+}
+
+
+//********************************************************************
+bool PartSet_WidgetFeaturePointSelector::setSelection(
+ QList<std::shared_ptr<ModuleBase_ViewerPrs>>& theValues,
+ const bool theToValidate)
+{
+ return false;
+ //return !theValues.empty();
+
+ /*ObjectPtr aBaseObject = myCurrentSubShape->object();
+ GeomShapePtr aBaseShape = myCurrentSubShape->shape();
+ bool aResult = aBaseObject.get() && aBaseShape.get();
+ // firstly set the selection to the attribute
+ if (aResult) {
+ QList<ModuleBase_ViewerPrsPtr> aValues;
+ aValues.append(myCurrentSubShape);
+ aResult = ModuleBase_WidgetShapeSelector::setSelection(aValues, theToValidate);
+ }
+ // secondly fill additional attributes
+ if (aResult) {
+ aResult = false;
+ if (aBaseShape->shapeType() == GeomAPI_Shape::EDGE) {
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aBaseShape));
+
+ std::shared_ptr<GeomAPI_Pnt> aFirstPnt = anEdge->firstPoint();
+ std::shared_ptr<GeomAPI_Pnt> aLastPnt = anEdge->lastPoint();
+
+ std::shared_ptr<GeomDataAPI_Point2D> aFirstPointAttr, aLastPointAttr;
+ /// find the points in base feature attributes
+ FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObject);
+ std::list<AttributePtr> a2DPointAttributes = aBaseFeature->data()->attributes(
+ GeomDataAPI_Point2D::typeId());
+ std::list<AttributePtr>::const_iterator anIt = a2DPointAttributes.begin(),
+ aLast = a2DPointAttributes.end();
+ for (; anIt != aLast; anIt++) {
+ std::shared_ptr<GeomDataAPI_Point2D> anAttributePoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(*anIt);
+ std::shared_ptr<GeomAPI_Pnt2d> aPoint2D = anAttributePoint->pnt();
+ std::shared_ptr<GeomAPI_Pnt> aPoint3D = PartSet_Tools::convertTo3D(aPoint2D->x(),
+ aPoint2D->y(), mySketch);
+ if (aFirstPnt->isEqual(aPoint3D))
+ aFirstPointAttr = anAttributePoint;
+ else if (aLastPnt->isEqual(aPoint3D))
+ aLastPointAttr = anAttributePoint;
+ }
+
+ /// find the points in coincident features
+ PntToAttributesMap aRefAttributes = myCashedReferences[aBaseObject];
+ PntToAttributesMap::const_iterator
+ aRIt = aRefAttributes.begin(), aRLast = aRefAttributes.end();
+ for (PntToAttributesMap::const_iterator aRIt = aRefAttributes.begin(),
+ aRLast = aRefAttributes.end(); aRIt != aRLast; aRIt++) {
+ std::shared_ptr<GeomDataAPI_Point2D> anAttribute = aRIt->first;
+ std::shared_ptr<GeomAPI_Pnt> aPoint = aRIt->second;
+ if (!aFirstPointAttr.get() && aFirstPnt->isEqual(aPoint))
+ aFirstPointAttr = anAttribute;
+ if (!aLastPointAttr.get() && aLastPnt->isEqual(aPoint))
+ aLastPointAttr = anAttribute;
+ if (aFirstPointAttr.get() && aLastPointAttr.get())
+ break;
+ }
+
+ /// find the points in objects that intersect the base feature
+ ObjectPtr aFirstPointObject, aLastPointObject;
+ if (myUseGraphicIntersection && (!aFirstPointAttr.get() || !aLastPointAttr.get())) {
+ PntToObjectsMap aRefObjects = myCashedObjects[aBaseObject];
+ PntToObjectsMap::const_iterator
+ anObjectIt = aRefObjects.begin(), anObjectLast = aRefObjects.end();
+ for (; anObjectIt != anObjectLast; anObjectIt++) {
+ std::list< std::shared_ptr<ModelAPI_Object> > anObjects = anObjectIt->second;
+ if (anObjects.empty())
+ continue;
+ std::shared_ptr<ModelAPI_Object> anObject = anObjects.front();
+ std::shared_ptr<GeomAPI_Pnt> aPoint = anObjectIt->first;
+ if (!aFirstPointAttr.get() && !aFirstPointObject.get() && aFirstPnt->isEqual(aPoint))
+ aFirstPointObject = anObject;
+ if (!aLastPointAttr.get() && !aLastPointObject.get() && aLastPnt->isEqual(aPoint))
+ aLastPointObject = anObject;
+ if (aFirstPointAttr.get() && aLastPointAttr.get())
+ break;
+ }
+ }
+
+ if ((!aFirstPointAttr.get() && !aFirstPointObject.get()) ||
+ (!aLastPointAttr.get() && !aLastPointObject.get()))
+ return false;
+
+ FeaturePtr aFeature = feature();
+ AttributeRefAttrPtr anAPointAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aFeature->attribute(SketchPlugin_Constraint::ENTITY_A()));
+ AttributeRefAttrPtr aBPointAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aFeature->attribute(SketchPlugin_Constraint::ENTITY_B()));
+ if (aFirstPointAttr.get())
+ anAPointAttr->setAttr(aFirstPointAttr);
+ else
+ anAPointAttr->setObject(aFirstPointObject);
+
+ if (aLastPointAttr.get())
+ aBPointAttr->setAttr(aLastPointAttr);
+ else
+ aBPointAttr->setObject(aLastPointObject);
+
+ if (myUseGraphicIntersection) {
+ // fill geometrical points
+ AttributePtr anAPointAttr = aFeature->attribute(SketchPlugin_Trim::ENTITY_A_POINT());
+ AttributePtr aBPointAttr = aFeature->attribute(SketchPlugin_Trim::ENTITY_B_POINT());
+ if (anAPointAttr.get() && aBPointAttr.get()) {
+ std::shared_ptr<GeomAPI_Pln> aPlane = PartSet_Tools::sketchPlane(sketch());
+
+ std::shared_ptr<GeomDataAPI_Point2D> anAPoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAPointAttr);
+ anAPoint->setValue(aFirstPnt->to2D(aPlane));
+
+ std::shared_ptr<GeomDataAPI_Point2D> aBPoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aBPointAttr);
+ aBPoint->setValue(aLastPnt->to2D(aPlane));
+ }
+ }
+ aResult = true;
+ }
+ }
+ return aResult;*/
+ return false;
+}
+
+void PartSet_WidgetFeaturePointSelector::setPreSelection(
+ const std::shared_ptr<ModuleBase_ViewerPrs>& thePreSelected,
+ ModuleBase_IViewWindow* theWnd,
+ QMouseEvent* theEvent)
+{
+ if (fillFeature(thePreSelected, theWnd, theEvent))
+ mouseReleased(theWnd, theEvent);
+}
+
+//********************************************************************
+/*bool PartSet_WidgetFeaturePointSelector::isValidSelectionCustom(
+ const std::shared_ptr<ModuleBase_ViewerPrs>& thePrs)
+{
+ // as we are modfying the attribute in move, we should not check validity here, by highlight
+ return false;
+}*/
+
+//********************************************************************
+/*void PartSet_WidgetFeaturePointSelector::getHighlighted(
+ QList<std::shared_ptr<ModuleBase_ViewerPrs>>& theValues)
+{
+ if (myCurrentSubShape.get() && myCurrentSubShape->object().get())
+ theValues.append(myCurrentSubShape);
+}*/
+
+//********************************************************************
+/*void PartSet_WidgetFeaturePointSelector::fillObjectShapes(const ObjectPtr& theObject)
+{
+ std::set<std::shared_ptr<GeomAPI_Shape> > aShapes;
+ std::map<std::shared_ptr<GeomDataAPI_Point2D>, std::shared_ptr<GeomAPI_Pnt> > aPointToAttributes;
+ std::map<std::shared_ptr<GeomAPI_Pnt>,
+ std::list< std::shared_ptr<ModelAPI_Object> > > aPointToObjects;
+
+ std::set<std::shared_ptr<GeomDataAPI_Point2D> > aRefAttributes;
+ // current feature
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
+ std::set<ResultPtr> anEdgeShapes;
+ // edges on feature
+ ModelAPI_Tools::shapesOfType(aFeature, GeomAPI_Shape::EDGE, anEdgeShapes);
+ if (!anEdgeShapes.empty()) {
+ GeomShapePtr aFeatureShape = (*anEdgeShapes.begin())->shape();
+
+ // coincidences to the feature
+ std::list<std::shared_ptr<GeomAPI_Pnt> > aPoints;
+
+ ModelGeomAlgo_Point2D::getPointsOfReference(aFeature, SketchPlugin_ConstraintCoincidence::ID(),
+ aRefAttributes, SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID());
+ // layed on feature coincidences to divide it on several shapes
+ CompositeFeaturePtr aSketch = sketch();
+ std::shared_ptr<ModelAPI_Data> aData = aSketch->data();
+ std::shared_ptr<GeomDataAPI_Point> aC = std::dynamic_pointer_cast<GeomDataAPI_Point>(
+ aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
+ std::shared_ptr<GeomDataAPI_Dir> aX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+ aData->attribute(SketchPlugin_Sketch::DIRX_ID()));
+ std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+ aData->attribute(SketchPlugin_Sketch::NORM_ID()));
+ std::shared_ptr<GeomAPI_Dir> aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir())));
+ ModelGeomAlgo_Point2D::getPointsInsideShape(aFeatureShape, aRefAttributes, aC->pnt(),
+ aX->dir(), aY, aPoints, aPointToAttributes);
+
+ // intersection points
+ if (myUseGraphicIntersection) {
+ std::list<FeaturePtr> aFeatures;
+ for (int i = 0; i < aSketch->numberOfSubs(); i++) {
+ FeaturePtr aFeature = aSketch->subFeature(i);
+ if (aFeature.get())
+ aFeatures.push_back(aFeature);
+ }
+ ModelGeomAlgo_Point2D::getPointsIntersectedShape(aFeature, aFeatures, aPoints,
+ aPointToObjects);
+ }
+ GeomAlgoAPI_ShapeTools::splitShape(aFeatureShape, aPoints, aShapes);
+ }
+ myCashedShapes[theObject] = aShapes;
+ myCashedReferences[theObject] = aPointToAttributes;
+ if (myUseGraphicIntersection)
+ myCashedObjects[theObject] = aPointToObjects;
+}
+*/
--- /dev/null
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
+
+// File: PartSet_WidgetFeaturePointSelector.h
+// Created: 28 Feb 2017
+// Author: Natalia ERMOLAEVA
+
+
+#ifndef PartSet_WidgetFeaturePointSelector_H
+#define PartSet_WidgetFeaturePointSelector_H
+
+#include <ModelAPI_CompositeFeature.h>
+#include <ModuleBase_WidgetShapeSelector.h>
+
+#include "PartSet.h"
+#include "PartSet_MouseProcessor.h"
+
+#include <Quantity_Color.hxx>
+
+#include <QObject>
+
+#include <set>
+#include <map>
+
+class ModuleBase_IWorkshop;
+class Config_WidgetAPI;
+class ModuleBase_IViewWindow;
+class ModuleBase_ViewerPrs;
+
+class GeomAPI_Pnt;
+class GeomDataAPI_Point2D;
+
+class QWidget;
+class QMouseEvent;
+
+/**
+* \ingroup Modules
+* Customosation of PartSet_WidgetFeaturePointSelector in order to visualize sub-shape
+* by mouse move over shape in the viewer. Split of the object is performed by
+* coincident points to the object. Segment between nearest coincidence is highlighted
+*/
+class PARTSET_EXPORT PartSet_WidgetFeaturePointSelector: public ModuleBase_WidgetShapeSelector,
+ public PartSet_MouseProcessor
+{
+Q_OBJECT
+ public:
+ /// Constructor
+ /// \param theParent the parent object
+ /// \param theWorkshop instance of workshop interface
+ /// \param theData the widget configuation. The attribute of the model widget is obtained from
+ PartSet_WidgetFeaturePointSelector(QWidget* theParent, ModuleBase_IWorkshop* theWorkshop,
+ const Config_WidgetAPI* theData);
+
+ virtual ~PartSet_WidgetFeaturePointSelector();
+
+ /// Checks all widget validator if the owner is valid. Firstly it checks custom widget validating,
+ /// next, the attribute's validating. It trying on the give selection to current attribute by
+ /// setting the value inside and calling validators. After this, the previous attribute value is
+ /// restored.The valid/invalid value is cashed.
+ /// \param theValue a selected presentation in the view
+ /// \return a boolean value
+ virtual bool isValidSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& theValue);
+
+ /// Set sketcher
+ /// \param theSketch a sketcher object
+ void setSketcher(CompositeFeaturePtr theSketch) { mySketch = theSketch; }
+
+ /// Retrurns installed sketcher
+ CompositeFeaturePtr sketch() const { return mySketch; }
+
+ /// The methiod called when widget is deactivated
+ virtual void deactivate();
+
+ /// Processing the mouse move event in the viewer
+ /// \param theWindow a view window
+ /// \param theEvent a mouse event
+ virtual void mouseMoved(ModuleBase_IViewWindow* theWindow, QMouseEvent* theEvent);
+
+ /// Processing the mouse release event in the viewer
+ /// \param theWindow a view window
+ /// \param theEvent a mouse event
+ virtual void mouseReleased(ModuleBase_IViewWindow* theWindow, QMouseEvent* theEvent);
+
+ /// Returns values which should be highlighted when the whidget is active
+ /// \param theValues a list of presentations
+ //virtual void getHighlighted(QList<std::shared_ptr<ModuleBase_ViewerPrs>>& theValues);
+
+ /// Set the given wrapped value to the current widget
+ /// This value should be processed in the widget according to the needs
+ /// The method is called by the current operation to process the operation preselection.
+ /// It is redefined to fill attributes responsible for the sub selection
+ /// \param theValues the wrapped selection values
+ /// \param theToValidate a flag on validation of the values
+ virtual bool setSelection(QList<std::shared_ptr<ModuleBase_ViewerPrs>>& theValues,
+ const bool theToValidate);
+
+ /// Fill preselection used in mouseReleased
+ //virtual void setPreSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& thePreSelected);
+ virtual void setPreSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& thePreSelected,
+ ModuleBase_IViewWindow* theWnd,
+ QMouseEvent* theEvent);
+protected:
+ /// Checks the widget validity. By default, it returns true.
+ /// \param thePrs a selected presentation in the view
+ /// \return a boolean value
+ //virtual bool isValidSelectionCustom(const std::shared_ptr<ModuleBase_ViewerPrs>& thePrs);
+
+ /// Return an object and geom shape by the viewer presentation
+ /// \param thePrs a selection
+ /// \param theObject an output object
+ /// \param theShape a shape of the selection
+ //virtual void getGeomSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& thePrs,
+ // ObjectPtr& theObject,
+ // GeomShapePtr& theShape);
+ //void fillObjectShapes(const ObjectPtr& theObject);
+
+ /// Return an object and geom shape by the viewer presentation
+ /// \param thePrs a selection
+ /// \param theObject an output object
+ /// \param theShape a shape of the selection
+ //virtual void getGeomSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& thePrs,
+ // ObjectPtr& theObject,
+ // GeomShapePtr& theShape);
+
+ /// Return the attribute values wrapped in a list of viewer presentations
+ /// \return a list of viewer presentations, which contains an attribute result and
+ /// a shape. If the attribute do not uses the shape, it is empty
+ virtual QList<std::shared_ptr<ModuleBase_ViewerPrs>> getAttributeSelection() const;
+
+protected:
+ /// The methiod called when widget is activated
+ virtual void activateCustom();
+
+protected:
+ bool fillFeature(const std::shared_ptr<ModuleBase_ViewerPrs>& theSelectedPrs,
+ ModuleBase_IViewWindow* theWnd,
+ QMouseEvent* theEvent);
+ //std::shared_ptr<ModuleBase_ViewerPrs> myCurrentSubShape;
+ //std::map<ObjectPtr, std::set<GeomShapePtr> > myCashedShapes;
+
+ //typedef std::map<std::shared_ptr<GeomDataAPI_Point2D>,
+ // std::shared_ptr<GeomAPI_Pnt> > PntToAttributesMap;
+ //std::map<ObjectPtr, PntToAttributesMap> myCashedReferences;
+
+ //typedef std::map<std::shared_ptr<GeomAPI_Pnt>,
+ // std::list< std::shared_ptr<ModelAPI_Object> > > PntToObjectsMap;
+ //std::map<ObjectPtr, PntToObjectsMap> myCashedObjects;
+
+ /// Pointer to a sketch
+ CompositeFeaturePtr mySketch;
+ bool myUseGraphicIntersection;
+ Quantity_Color myHighlightColor;
+ Quantity_Color mySelectionColor;
+};
+
+#endif
\ No newline at end of file
}
void PartSet_WidgetPoint2D::setPreSelection(
- const std::shared_ptr<ModuleBase_ViewerPrs>& thePreSelected)
+ const std::shared_ptr<ModuleBase_ViewerPrs>& thePreSelected,
+ ModuleBase_IViewWindow* theWnd,
+ QMouseEvent* theEvent)
{
myPreSelected = thePreSelected;
+ mouseReleased(theWnd, theEvent);
+ myPreSelected = ModuleBase_ViewerPrsPtr();
}
void PartSet_WidgetPoint2D::mouseMoved(ModuleBase_IViewWindow* theWindow, QMouseEvent* theEvent)
virtual void mouseReleased(ModuleBase_IViewWindow* theWindow, QMouseEvent* theEvent);
/// Fill preselection used in mouseReleased
- void setPreSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& thePreSelected);
+ //virtual void setPreSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& thePreSelected);
+ virtual void setPreSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& thePreSelected,
+ ModuleBase_IViewWindow* theWnd,
+ QMouseEvent* theEvent);
signals:
/// Signal about selection of an existing vertex from an object
ModuleBase_LabelValue* myXSpin; ///< the label for the X coordinate
ModuleBase_LabelValue* myYSpin; ///< the label for the Y coordinate
- /// value used as selection in mouse release method
+ /// value used as selection in mouse release method
std::shared_ptr<ModuleBase_ViewerPrs> myPreSelected;
/// it is important during restart operation
#include <SketchPlugin_ConstraintCoincidence.h>
#include <SketchPlugin_Constraint.h>
#include <SketchPlugin_Point.h>
+#include <SketchPlugin_Trim.h>
#include <ModuleBase_IViewWindow.h>
#include <ModuleBase_IWorkshop.h>
const Config_WidgetAPI* theData)
: ModuleBase_WidgetShapeSelector(theParent, theWorkshop, theData)
{
+ myUseGraphicIntersection = theData->getBooleanAttribute("use_graphic_intersection", false);
myCurrentSubShape = std::shared_ptr<ModuleBase_ViewerPrs>(new ModuleBase_ViewerPrs());
}
std::shared_ptr<GeomAPI_Pnt> aLastPnt = anEdge->lastPoint();
std::shared_ptr<GeomDataAPI_Point2D> aFirstPointAttr, aLastPointAttr;
- /// find the points in feature attributes
+ /// find the points in base feature attributes
FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObject);
std::list<AttributePtr> a2DPointAttributes = aBaseFeature->data()->attributes(
GeomDataAPI_Point2D::typeId());
PntToAttributesMap aRefAttributes = myCashedReferences[aBaseObject];
PntToAttributesMap::const_iterator
aRIt = aRefAttributes.begin(), aRLast = aRefAttributes.end();
- for (; aRIt != aRLast; aRIt++) {
+ for (PntToAttributesMap::const_iterator aRIt = aRefAttributes.begin(),
+ aRLast = aRefAttributes.end(); aRIt != aRLast; aRIt++) {
std::shared_ptr<GeomDataAPI_Point2D> anAttribute = aRIt->first;
std::shared_ptr<GeomAPI_Pnt> aPoint = aRIt->second;
if (!aFirstPointAttr.get() && aFirstPnt->isEqual(aPoint))
if (aFirstPointAttr.get() && aLastPointAttr.get())
break;
}
- if (!aFirstPointAttr.get() || !aLastPointAttr)
+
+ /// find the points in objects that intersect the base feature
+ ObjectPtr aFirstPointObject, aLastPointObject;
+ if (myUseGraphicIntersection && (!aFirstPointAttr.get() || !aLastPointAttr.get())) {
+ PntToObjectsMap aRefObjects = myCashedObjects[aBaseObject];
+ PntToObjectsMap::const_iterator
+ anObjectIt = aRefObjects.begin(), anObjectLast = aRefObjects.end();
+ for (; anObjectIt != anObjectLast; anObjectIt++) {
+ std::list< std::shared_ptr<ModelAPI_Object> > anObjects = anObjectIt->second;
+ if (anObjects.empty())
+ continue;
+ std::shared_ptr<ModelAPI_Object> anObject = anObjects.front();
+ std::shared_ptr<GeomAPI_Pnt> aPoint = anObjectIt->first;
+ if (!aFirstPointAttr.get() && !aFirstPointObject.get() && aFirstPnt->isEqual(aPoint))
+ aFirstPointObject = anObject;
+ if (!aLastPointAttr.get() && !aLastPointObject.get() && aLastPnt->isEqual(aPoint))
+ aLastPointObject = anObject;
+ if (aFirstPointAttr.get() && aLastPointAttr.get())
+ break;
+ }
+ }
+
+ if ((!aFirstPointAttr.get() && !aFirstPointObject.get()) ||
+ (!aLastPointAttr.get() && !aLastPointObject.get()))
return false;
FeaturePtr aFeature = feature();
aFeature->attribute(SketchPlugin_Constraint::ENTITY_A()));
AttributeRefAttrPtr aBPointAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
aFeature->attribute(SketchPlugin_Constraint::ENTITY_B()));
- anAPointAttr->setAttr(aFirstPointAttr);
- aBPointAttr->setAttr(aLastPointAttr);
+ if (aFirstPointAttr.get())
+ anAPointAttr->setAttr(aFirstPointAttr);
+ else
+ anAPointAttr->setObject(aFirstPointObject);
+
+ if (aLastPointAttr.get())
+ aBPointAttr->setAttr(aLastPointAttr);
+ else
+ aBPointAttr->setObject(aLastPointObject);
+
+ /*if (myUseGraphicIntersection) {
+ // fill geometrical points
+ AttributePtr anAPointAttr = aFeature->attribute(SketchPlugin_Trim::ENTITY_A_POINT());
+ AttributePtr aBPointAttr = aFeature->attribute(SketchPlugin_Trim::ENTITY_B_POINT());
+ if (anAPointAttr.get() && aBPointAttr.get()) {
+ std::shared_ptr<GeomAPI_Pln> aPlane = PartSet_Tools::sketchPlane(sketch());
+
+ std::shared_ptr<GeomDataAPI_Point2D> anAPoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAPointAttr);
+ anAPoint->setValue(aFirstPnt->to2D(aPlane));
+
+ std::shared_ptr<GeomDataAPI_Point2D> aBPoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aBPointAttr);
+ aBPoint->setValue(aLastPnt->to2D(aPlane));
+ }
+ }*/
aResult = true;
}
}
{
std::set<std::shared_ptr<GeomAPI_Shape> > aShapes;
std::map<std::shared_ptr<GeomDataAPI_Point2D>, std::shared_ptr<GeomAPI_Pnt> > aPointToAttributes;
+ std::map<std::shared_ptr<GeomAPI_Pnt>,
+ std::list< std::shared_ptr<ModelAPI_Object> > > aPointToObjects;
+
std::set<std::shared_ptr<GeomDataAPI_Point2D> > aRefAttributes;
// current feature
FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
- std::set<GeomShapePtr> anEdgeShapes;
+ std::set<ResultPtr> anEdgeShapes;
// edges on feature
ModelAPI_Tools::shapesOfType(aFeature, GeomAPI_Shape::EDGE, anEdgeShapes);
if (!anEdgeShapes.empty()) {
- GeomShapePtr aFeatureShape = *anEdgeShapes.begin();
+ GeomShapePtr aFeatureShape = (*anEdgeShapes.begin())->shape();
// coincidences to the feature
+ std::list<std::shared_ptr<GeomAPI_Pnt> > aPoints;
+
ModelGeomAlgo_Point2D::getPointsOfReference(aFeature, SketchPlugin_ConstraintCoincidence::ID(),
aRefAttributes, SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID());
// layed on feature coincidences to divide it on several shapes
std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
aData->attribute(SketchPlugin_Sketch::NORM_ID()));
std::shared_ptr<GeomAPI_Dir> aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir())));
- std::list<std::shared_ptr<GeomAPI_Pnt> > aPoints;
- ModelGeomAlgo_Point2D::getPointsInsideShape(aFeatureShape, aRefAttributes, aC->pnt(),
+ ModelGeomAlgo_Point2D::getPointsInsideShape_p(aFeatureShape, aRefAttributes, aC->pnt(),
aX->dir(), aY, aPoints, aPointToAttributes);
- GeomAlgoAPI_ShapeTools::splitShape(aFeatureShape, aPoints, aShapes);
+ // intersection points
+ /*if (myUseGraphicIntersection) {
+ std::list<FeaturePtr> aFeatures;
+ for (int i = 0; i < aSketch->numberOfSubs(); i++) {
+ FeaturePtr aFeature = aSketch->subFeature(i);
+ if (aFeature.get())
+ aFeatures.push_back(aFeature);
+ }
+ ModelGeomAlgo_Point2D::getPointsIntersectedShape(aFeature, aFeatures, aPoints,
+ aPointToObjects);
+ }*/
+ GeomAlgoAPI_ShapeTools::splitShape_p(aFeatureShape, aPoints, aShapes);
}
myCashedShapes[theObject] = aShapes;
myCashedReferences[theObject] = aPointToAttributes;
+ if (myUseGraphicIntersection)
+ myCashedObjects[theObject] = aPointToObjects;
}
std::shared_ptr<GeomAPI_Pnt> > PntToAttributesMap;
std::map<ObjectPtr, PntToAttributesMap> myCashedReferences;
+ typedef std::map<std::shared_ptr<GeomAPI_Pnt>,
+ std::list< std::shared_ptr<ModelAPI_Object> > > PntToObjectsMap;
+ std::map<ObjectPtr, PntToObjectsMap> myCashedObjects;
+
/// Pointer to a sketch
CompositeFeaturePtr mySketch;
+ bool myUseGraphicIntersection;
};
#endif
\ No newline at end of file
#include <SketchPlugin_ConstraintRadius.h>
#include <SketchPlugin_ConstraintRigid.h>
#include <SketchPlugin_ConstraintSplit.h>
+#include <SketchPlugin_Trim.h>
#include <SketchPlugin_ConstraintTangent.h>
#include <SketchPlugin_ConstraintVertical.h>
#include <SketcherPrs_Tools.h>
return InterfacePtr(new ModelHighAPI_Interface(aFeature));
}
+//--------------------------------------------------------------------------------------
+std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::addTrim(
+ const ModelHighAPI_Reference& theFeature,
+ const std::shared_ptr<GeomAPI_Pnt2d>& thePositionPoint)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Trim::ID());
+ fillAttribute(theFeature, aFeature->reference(SketchPlugin_Trim::BASE_OBJECT()));
+
+ AttributePtr anAttribute = aFeature->attribute(SketchPlugin_Trim::ENTITY_POINT());
+ if (anAttribute->attributeType() == GeomDataAPI_Point2D::typeId()) {
+ AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttribute);
+ fillAttribute(thePositionPoint, aPointAttr);
+ }
+
+ return InterfacePtr(new ModelHighAPI_Interface(aFeature));
+}
+
//--------------------------------------------------------------------------------------
std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setAngle(
const ModelHighAPI_RefAttr & theLine1,
const ModelHighAPI_RefAttr& thePoint1,
const ModelHighAPI_RefAttr& thePoint2);
+ /// Add trim
+ SKETCHAPI_EXPORT
+ std::shared_ptr<ModelHighAPI_Interface> addTrim(
+ const ModelHighAPI_Reference& theFeature,
+ const std::shared_ptr<GeomAPI_Pnt2d>& thePositionPoint);
+
/// Set angle
SKETCHAPI_EXPORT
std::shared_ptr<ModelHighAPI_Interface> setAngle(
SketchPlugin_Sketch.h
SketchPlugin_SketchEntity.h
SketchPlugin_Tools.h
+ SketchPlugin_Trim.h
SketchPlugin_Validators.h
)
SketchPlugin_Sketch.cpp
SketchPlugin_SketchEntity.cpp
SketchPlugin_Tools.cpp
+ SketchPlugin_Trim.cpp
SketchPlugin_Validators.cpp
)
TestHighload.py
TestSnowflake.py
TestArcBehavior.py
+ Test1924.py
TestRemoveSketch.py
Test1061.py
Test1673.py
Test1924.py
Test1966.py
Test1967.py
-)
+ TestTrimCircle.py )
\ No newline at end of file
std::set<std::shared_ptr<GeomAPI_Shape> > aSplitShapes;
- GeomAlgoAPI_ShapeTools::splitShape(aBaseShape, aPoints, aSplitShapes);
+ GeomAlgoAPI_ShapeTools::splitShape_p(aBaseShape, aPoints, aSplitShapes);
std::shared_ptr<GeomAPI_Shape> aShape =
GeomAlgoAPI_ShapeTools::findShape(aPoints, aSplitShapes);
#include <SketchPlugin_ConstraintVertical.h>
#include <SketchPlugin_MultiRotation.h>
#include <SketchPlugin_MultiTranslation.h>
+#include <SketchPlugin_Trim.h>
#include <SketchPlugin_Validators.h>
#include <SketchPlugin_ExternalValidator.h>
return FeaturePtr(new SketchPlugin_MultiRotation);
} else if (theFeatureID == SketchPlugin_ConstraintAngle::ID()) {
return FeaturePtr(new SketchPlugin_ConstraintAngle);
+ } else if (theFeatureID == SketchPlugin_Trim::ID()) {
+ return FeaturePtr(new SketchPlugin_Trim);
}
// feature of such kind is not found
return FeaturePtr();
aMsg->setState(SketchPlugin_ConstraintAngle::ID(), aHasSketchPlane);
aMsg->setState(SketchPlugin_MultiRotation::ID(), aHasSketchPlane);
aMsg->setState(SketchPlugin_MultiTranslation::ID(), aHasSketchPlane);
+ aMsg->setState(SketchPlugin_Trim::ID(), aHasSketchPlane);
// SketchRectangle is a python feature, so its ID is passed just as a string
aMsg->setState("SketchRectangle", aHasSketchPlane);
}
--- /dev/null
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
+
+// File: SketchPlugin_Trim.cpp
+// Created: 22 Feb 2017
+// Author: Natalia ERMOLAEVA
+
+#include "SketchPlugin_Trim.h"
+
+#include <GeomAPI_Dir2d.h>
+#include <GeomAPI_Edge.h>
+#include <GeomAPI_Pnt2d.h>
+#include <GeomAPI_XY.h>
+#include <GeomDataAPI_Point2D.h>
+#include <GeomAlgoAPI_ShapeTools.h>
+
+#include <ModelAPI_AttributeReference.h>
+#include <ModelAPI_AttributeString.h>
+#include <ModelAPI_AttributeRefAttr.h>
+#include <ModelAPI_Tools.h>
+#include <ModelAPI_AttributeBoolean.h>
+
+#include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
+#include <ModelAPI_AttributeDouble.h>
+
+#include <SketchPlugin_Arc.h>
+#include <SketchPlugin_ConstraintMiddle.h>
+#include <SketchPlugin_Circle.h>
+#include <SketchPlugin_ConstraintCoincidence.h>
+#include <SketchPlugin_ConstraintEqual.h>
+//#include <SketchPlugin_ConstraintParallel.h>
+#include <SketchPlugin_ConstraintTangent.h>
+#include <SketchPlugin_ConstraintLength.h>
+#include <SketchPlugin_ConstraintMirror.h>
+#include <SketchPlugin_ConstraintCollinear.h>
+#include <SketchPlugin_Line.h>
+#include <SketchPlugin_MultiRotation.h>
+#include <SketchPlugin_MultiTranslation.h>
+#include <SketchPlugin_Point.h>
+
+#include <ModelAPI_Events.h>
+#include <SketchPlugin_Line.h>
+#include <SketchPlugin_Arc.h>
+#include <SketchPlugin_Circle.h>
+
+#include <ModelGeomAlgo_Point2D.h>
+#include <Events_Loop.h>
+
+#include <cmath>
+
+#define DEBUG_TRIM
+#ifdef DEBUG_TRIM
+#include <iostream>
+#endif
+
+static const double PI = 3.141592653589793238463;
+
+static const std::string OPERATION_HIGHLIGHT_COLOR() { return "128, 0, 0"; }
+
+SketchPlugin_Trim::SketchPlugin_Trim()
+{
+}
+
+void SketchPlugin_Trim::initAttributes()
+{
+ data()->addAttribute(SketchPlugin_Trim::BASE_OBJECT(), ModelAPI_AttributeReference::typeId());
+ data()->addAttribute(ENTITY_POINT(), GeomDataAPI_Point2D::typeId());
+}
+
+void SketchPlugin_Trim::findShapePoints(std::shared_ptr<GeomAPI_Pnt>& aStartPoint,
+ std::shared_ptr<GeomAPI_Pnt>& aLastPoint)
+{
+ AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ ObjectPtr aBaseObject = aBaseObjectAttr->value();
+
+ AttributePoint2DPtr aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ data()->attribute(ENTITY_POINT()));
+ std::shared_ptr<GeomAPI_Pnt2d> anAttributePnt2d = aPoint->pnt();
+ std::shared_ptr<GeomAPI_Pnt> anAttributePnt = sketch()->to3D(anAttributePnt2d->x(),
+ anAttributePnt2d->y());
+
+ if (myCashedShapes.find(aBaseObject) == myCashedShapes.end())
+ fillObjectShapes(aBaseObject);
+
+ const std::set<GeomShapePtr>& aShapes = myCashedShapes[aBaseObject];
+ if (!aShapes.empty()) {
+ std::set<GeomShapePtr>::const_iterator anIt = aShapes.begin(), aLast = aShapes.end();
+ for (; anIt != aLast; anIt++) {
+ GeomShapePtr aBaseShape = *anIt;
+ std::shared_ptr<GeomAPI_Pnt> aProjectedPoint;
+ if (ModelGeomAlgo_Point2D::isPointOnEdge(aBaseShape, anAttributePnt, aProjectedPoint)) {
+
+ if (aBaseShape->shapeType() == GeomAPI_Shape::EDGE) {
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aBaseShape));
+ aStartPoint = anEdge->lastPoint();
+ aLastPoint = anEdge->firstPoint();
+ }
+ }
+ }
+ }
+#ifdef DEBUG_TRIM
+ std::cout << "<findShapePoints> => "
+ << "Start Point: ["
+ << aStartPoint->x() << ", " << aStartPoint->y() << ", " << aStartPoint->z() << "]"
+ << "Last Point: ["
+ << aLastPoint->x() << ", " << aLastPoint->y() << ", " << aLastPoint->z() << "]"
+ << std::endl;
+#endif
+}
+
+std::shared_ptr<GeomAPI_Pnt2d> SketchPlugin_Trim::convertPoint(
+ const std::shared_ptr<GeomAPI_Pnt>& thePoint)
+{
+ std::shared_ptr<GeomAPI_Pnt2d> aPoint;
+
+ AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ ObjectPtr aBaseObject = aBaseObjectAttr->value();
+ if (myObjectToPoints.find(aBaseObject) == myObjectToPoints.end())
+ return aPoint;
+
+ bool aFound = false;
+ const PointToRefsMap& aRefsMap = myObjectToPoints.at(aBaseObject);
+ for (PointToRefsMap::const_iterator aPointIt = aRefsMap.begin();
+ aPointIt != aRefsMap.end() && !aFound; aPointIt++) {
+ if (aPointIt->first->isEqual(thePoint)) {
+ const std::pair<std::list<AttributePoint2DPtr >,
+ std::list<ObjectPtr > >& anInfo = aPointIt->second;
+ const std::list<AttributePoint2DPtr >& anAttributes = anInfo.first;
+ if (!anAttributes.empty()) {
+ aPoint = anAttributes.front()->pnt();
+ aFound = true;
+ }
+ else {
+ std::shared_ptr<GeomAPI_Pln> aPlane = sketch()->plane();
+ aPoint = thePoint->to2D(aPlane);
+ aFound = true;
+ }
+ }
+ }
+ if (!aFound) {
+ // returns an end of the shape to define direction of split if feature's attribute participates
+ std::shared_ptr<GeomAPI_Pln> aPlane = sketch()->plane();
+ aPoint = thePoint->to2D(aPlane);
+ }
+ return aPoint;
+}
+
+void SketchPlugin_Trim::execute()
+{
+#ifdef DEBUG_TRIM
+ std::cout << "SketchPlugin_Trim::execute" << std::endl;
+#endif
+
+ SketchPlugin_Sketch* aSketch = sketch();
+ if (!aSketch)
+ return;
+
+ // Check the base objects are initialized.
+ AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ if(!aBaseObjectAttr->isInitialized()) {
+ setError("Error: Base object is not initialized.");
+ return;
+ }
+ ObjectPtr aBaseObject = aBaseObjectAttr->value();
+ if (!aBaseObject.get())
+ return;
+ FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
+
+ /// points of trim
+ std::shared_ptr<GeomAPI_Pnt> aStartShapePoint, aLastShapePoint;
+ findShapePoints(aStartShapePoint, aLastShapePoint);
+ std::shared_ptr<GeomAPI_Pnt2d> aStartShapePoint2d = convertPoint(aStartShapePoint);
+
+ std::shared_ptr<GeomAPI_Pnt2d> aLastShapePoint2d = convertPoint(aLastShapePoint);
+
+ std::set<FeaturePtr> aFeaturesToDelete, aFeaturesToUpdate;
+ getConstraints(aFeaturesToDelete, aFeaturesToUpdate);
+
+ std::map<AttributePtr, std::list<AttributePtr> > aBaseRefAttributes;
+ std::list<AttributePtr> aRefsToFeature;
+ getRefAttributes(aBaseFeature, aBaseRefAttributes, aRefsToFeature);
+
+ std::set<AttributePoint2DPtr> aFurtherCoincidences;
+ std::set<FeaturePtr> aCreatedFeatures;
+ std::set<std::pair<AttributePtr, AttributePtr>> aModifiedAttributes;
+ const std::string& aKind = aBaseFeature->getKind();
+ if (aKind == SketchPlugin_Circle::ID()) {
+ trimCircle(aStartShapePoint2d, aLastShapePoint2d,
+ aFurtherCoincidences, aCreatedFeatures, aModifiedAttributes);
+ updateRefFeatureConstraints(getFeatureResult(aBaseFeature), aRefsToFeature);
+
+ aFeaturesToDelete.insert(aBaseFeature);
+ // as circle is removed, temporary fill this attribute
+ aBaseObjectAttr->setObject(ResultPtr());
+ }
+ else if (aKind == SketchPlugin_Line::ID()) {
+ trimLine(aStartShapePoint2d, aLastShapePoint2d,
+ aFurtherCoincidences, aCreatedFeatures, aModifiedAttributes);
+ }
+ else if (aKind == SketchPlugin_Arc::ID()) {
+ trimArc(aStartShapePoint2d, aLastShapePoint2d,
+ aFurtherCoincidences, aCreatedFeatures, aModifiedAttributes);
+ }
+
+ // coincidence to result points
+ const PointToRefsMap& aRefsMap = myObjectToPoints.at(aBaseObject);
+ std::set<AttributePoint2DPtr>::const_iterator anIt = aFurtherCoincidences.begin(),
+ aLast = aFurtherCoincidences.end();
+ for (; anIt != aLast; anIt++) {
+ AttributePoint2DPtr aPointAttribute = (*anIt);
+ std::shared_ptr<GeomAPI_Pnt2d> aPoint2d = aPointAttribute->pnt();
+
+ std::shared_ptr<GeomAPI_Pnt> aPoint;
+ if (aStartShapePoint2d.get() && aPoint2d->isEqual(aStartShapePoint2d))
+ aPoint = aStartShapePoint;
+ else if (aLastShapePoint2d.get() && aPoint2d->isEqual(aLastShapePoint2d))
+ aPoint = aLastShapePoint;
+
+ if (!aPoint.get())
+ continue;
+
+ std::pair<std::list<AttributePoint2DPtr >, std::list<ObjectPtr > > anInfo;
+ for (PointToRefsMap::const_iterator aRefIt = aRefsMap.begin(); aRefIt != aRefsMap.end();
+ aRefIt++)
+ {
+ if (aRefIt->first->isEqual(aPoint)) {
+ anInfo = aRefIt->second;
+ break;
+ }
+ }
+ const std::list<AttributePoint2DPtr >& anAttributes = anInfo.first;
+ for (std::list<AttributePoint2DPtr>::const_iterator anAttrIt = anAttributes.begin();
+ anAttrIt != anAttributes.end(); anAttrIt++) {
+ createConstraint(SketchPlugin_ConstraintCoincidence::ID(), aPointAttribute, *anAttrIt);
+ }
+
+ const std::list<ObjectPtr>& anObjects = anInfo.second;
+ for (std::list<ObjectPtr>::const_iterator anObjectIt = anObjects.begin();
+ anObjectIt != anObjects.end(); anObjectIt++) {
+ createConstraint(SketchPlugin_ConstraintCoincidence::ID(), aPointAttribute, *anObjectIt);
+ }
+ }
+
+ // Wait all constraints being created, then send update events
+ static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
+ bool isUpdateFlushed = Events_Loop::loop()->isFlushed(anUpdateEvent);
+ if (isUpdateFlushed)
+ Events_Loop::loop()->setFlushed(anUpdateEvent, false);
+
+ updateRefAttConstraints(aBaseRefAttributes, aModifiedAttributes, aFeaturesToDelete);
+
+ // delete constraints
+#ifdef DEBUG_TRIM
+ std::cout << "remove features and references:" << std::endl;
+ std::set<FeaturePtr>::const_iterator aDIt = aFeaturesToDelete.begin(),
+ aDLast = aFeaturesToDelete.end();
+ for (; aDIt != aDLast; aDIt++) {
+ //std::cout << getFeatureInfo(*aDIt, false) << std::endl;
+ //std::cout << std::endl;
+ }
+#endif
+ ModelAPI_Tools::removeFeaturesAndReferences(aFeaturesToDelete);
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
+
+ // Send events to update the sub-features by the solver.
+ if(isUpdateFlushed) {
+ Events_Loop::loop()->setFlushed(anUpdateEvent, true);
+ }
+
+#ifdef DEBUG_TRIM
+ std::cout << "SketchPlugin_Trim::done" << std::endl;
+#endif
+}
+
+bool SketchPlugin_Trim::isMacro() const
+{
+ return true;
+}
+
+AISObjectPtr SketchPlugin_Trim::getAISObject(AISObjectPtr thePrevious)
+{
+ AISObjectPtr anAIS = thePrevious;
+ // feature for trim
+ AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ ObjectPtr aBaseObject = aBaseObjectAttr->value();
+ if (!aBaseObject.get())
+ return anAIS;
+ FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
+
+ // point on feature
+ AttributePoint2DPtr aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ data()->attribute(ENTITY_POINT()));
+ std::shared_ptr<GeomAPI_Pnt2d> anAttributePnt2d = aPoint->pnt();
+ std::shared_ptr<GeomAPI_Pnt> anAttributePnt = sketch()->to3D(anAttributePnt2d->x(), anAttributePnt2d->y());
+
+ if (myCashedShapes.find(aBaseObject) == myCashedShapes.end())
+ fillObjectShapes(aBaseObject);
+
+ const std::set<GeomShapePtr>& aShapes = myCashedShapes[aBaseObject];
+ if (!aShapes.empty()) {
+ std::set<GeomShapePtr>::const_iterator anIt = aShapes.begin(), aLast = aShapes.end();
+ for (; anIt != aLast; anIt++) {
+ GeomShapePtr aBaseShape = *anIt;
+ std::shared_ptr<GeomAPI_Pnt> aProjectedPoint;
+ if (ModelGeomAlgo_Point2D::isPointOnEdge(aBaseShape, anAttributePnt, aProjectedPoint)) {
+ if (aBaseShape) {
+ if (!anAIS)
+ anAIS = AISObjectPtr(new GeomAPI_AISObject);
+ anAIS->createShape(aBaseShape);
+
+ std::shared_ptr<ModelAPI_AttributeBoolean> anAuxiliaryAttr =
+ aBaseFeature->data()->boolean(SketchPlugin_SketchEntity::AUXILIARY_ID());
+
+ bool isConstruction = anAuxiliaryAttr.get() != NULL && anAuxiliaryAttr->value();
+
+ std::vector<int> aColor;
+ aColor = Config_PropManager::color("Visualization", "operation_highlight_color",
+ OPERATION_HIGHLIGHT_COLOR());
+ double aWidth = SketchPlugin_SketchEntity::SKETCH_LINE_WIDTH();
+ int aLineStyle = SketchPlugin_SketchEntity::SKETCH_LINE_STYLE();
+ if (isConstruction) {
+ aWidth = SketchPlugin_SketchEntity::SKETCH_LINE_WIDTH_AUXILIARY();
+ aLineStyle = SketchPlugin_SketchEntity::SKETCH_LINE_STYLE_AUXILIARY();
+ }
+ anAIS->setColor(aColor[0], aColor[1], aColor[2]);
+ // modification of width should be replaced to value 1 after highlight problem is fixed
+ anAIS->setWidth(aWidth + 2);//1);
+ anAIS->setLineStyle(aLineStyle);
+ break;
+ }
+ }
+ }
+ }
+
+ return anAIS;
+}
+
+void SketchPlugin_Trim::getFeaturePoints(const FeaturePtr& theFeature,
+ AttributePoint2DPtr& theStartPointAttr,
+ AttributePoint2DPtr& theEndPointAttr)
+{
+ std::string aFeatureKind = theFeature->getKind();
+ std::string aStartAttributeName, anEndAttributeName;
+ if (aFeatureKind == SketchPlugin_Line::ID()) {
+ aStartAttributeName = SketchPlugin_Line::START_ID();
+ anEndAttributeName = SketchPlugin_Line::END_ID();
+ }
+ else if (aFeatureKind == SketchPlugin_Arc::ID()) {
+ aStartAttributeName = SketchPlugin_Arc::START_ID();
+ anEndAttributeName = SketchPlugin_Arc::END_ID();
+ }
+ if (!aStartAttributeName.empty() && !anEndAttributeName.empty()) {
+ theStartPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theFeature->attribute(aStartAttributeName));
+ theEndPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theFeature->attribute(anEndAttributeName));
+ }
+}
+
+void SketchPlugin_Trim::getConstraints(std::set<FeaturePtr>& theFeaturesToDelete,
+ std::set<FeaturePtr>& theFeaturesToUpdate)
+{
+ std::shared_ptr<ModelAPI_Data> aData = data();
+
+ // Check the base objects are initialized.
+ AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ aData->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
+ ResultPtr aBaseFeatureResult = getFeatureResult(aBaseFeature);
+
+ std::set<AttributePtr> aRefsList = aBaseFeatureResult->data()->refsToMe();
+ std::set<AttributePtr> aFRefsList = aBaseFeature->data()->refsToMe();
+ aRefsList.insert(aFRefsList.begin(), aFRefsList.end());
+
+ std::set<AttributePtr>::const_iterator aIt;
+ for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
+ std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
+ FeaturePtr aRefFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
+ std::string aRefFeatureKind = aRefFeature->getKind();
+ if (aRefFeatureKind == SketchPlugin_ConstraintMirror::ID() ||
+ aRefFeatureKind == SketchPlugin_MultiRotation::ID() ||
+ aRefFeatureKind == SketchPlugin_MultiTranslation::ID() ||
+ aRefFeatureKind == SketchPlugin_ConstraintMiddle::ID())
+ theFeaturesToDelete.insert(aRefFeature);
+ else if (aRefFeatureKind == SketchPlugin_ConstraintLength::ID())
+ theFeaturesToUpdate.insert(aRefFeature);
+ else if (aRefFeatureKind == SketchPlugin_ConstraintTangent::ID()) {
+ if (aBaseFeature->getKind() == SketchPlugin_Circle::ID()) /// TEMPORARY limitaion
+ /// until tangency between arc and line is implemented
+ theFeaturesToDelete.insert(aRefFeature);
+ else {
+ std::string anAttributeToBeModified;
+ AttributePoint2DPtr aTangentPoint;
+ ObjectPtr aResult1 = aRefFeature->refattr(SketchPlugin_Constraint::ENTITY_A())->object();
+ ObjectPtr aResult2 = aRefFeature->refattr(SketchPlugin_Constraint::ENTITY_B())->object();
+ if (aResult1.get() && aResult2.get()) {
+ FeaturePtr aCoincidenceFeature =
+ SketchPlugin_ConstraintCoincidence::findCoincidenceFeature
+ (ModelAPI_Feature::feature(aResult1),
+ ModelAPI_Feature::feature(aResult2));
+ // get the point not lying on the splitting feature
+ for (int i = 0; i < CONSTRAINT_ATTR_SIZE; ++i) {
+ AttributeRefAttrPtr aRefAttr = aCoincidenceFeature->refattr(SketchPlugin_Trim::BASE_OBJECT());
+ if (!aRefAttr || aRefAttr->isObject())
+ continue;
+ AttributePoint2DPtr aPoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aRefAttr->attr());
+ if (!aPoint)
+ continue;
+ if (aPoint->owner() != aBaseFeature) {
+ aTangentPoint = aPoint;
+ break;
+ }
+ }
+ }
+ if (aTangentPoint.get()) {
+ //FeaturePtr aFeature1 = ModelAPI_Feature::feature(aResult1);
+ //std::string anAttributeToBeModified = aFeature1 == aBaseFeature
+ // ? SketchPlugin_Constraint::ENTITY_A() : SketchPlugin_Constraint::ENTITY_B();
+ //theTangentFeatures[aRefFeature] = std::make_pair(anAttributeToBeModified, aTangentPoint);
+ }
+ else /// there is not coincident point between tangent constraint
+ theFeaturesToDelete.insert(aRefFeature);
+ }
+ }
+ }
+}
+
+void SketchPlugin_Trim::getRefAttributes(const FeaturePtr& theFeature,
+ std::map<AttributePtr, std::list<AttributePtr> >& theRefs,
+ std::list<AttributePtr>& theRefsToFeature)
+{
+ theRefs.clear();
+
+ std::list<AttributePtr> aPointAttributes =
+ theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+ std::set<AttributePtr> aPointAttributesSet;
+
+ std::list<AttributePtr>::const_iterator aPIt =
+ aPointAttributes.begin(), aPLast = aPointAttributes.end();
+ for (; aPIt != aPLast; aPIt++)
+ aPointAttributesSet.insert(*aPIt);
+
+ std::set<AttributePtr> aRefsAttributes = getFeatureResult(theFeature)->data()->refsToMe();
+ std::set<AttributePtr> aFRefsList = theFeature->data()->refsToMe();
+ aRefsAttributes.insert(aFRefsList.begin(), aFRefsList.end());
+
+ std::set<AttributePtr>::const_iterator aIt;
+ for (aIt = aRefsAttributes.cbegin(); aIt != aRefsAttributes.cend(); ++aIt) {
+ AttributePtr anAttr = (*aIt);
+ FeaturePtr anAttrFeature = ModelAPI_Feature::feature(anAttr->owner());
+ if (anAttrFeature.get() != this &&
+ anAttr.get() && anAttr->attributeType() == ModelAPI_AttributeRefAttr::typeId()) {
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttr);
+ if (!aRefAttr->isObject()) { /// find attributes referenced to feature point attributes
+ AttributePtr anAttrInRef = aRefAttr->attr();
+ if (anAttrInRef.get() &&
+ aPointAttributesSet.find(anAttrInRef) != aPointAttributesSet.end()) {
+ if (theRefs.find(anAttrInRef) != theRefs.end())
+ theRefs[anAttrInRef].push_back(aRefAttr);
+ else {
+ std::list<AttributePtr> anAttrList;
+ anAttrList.push_back(aRefAttr);
+ theRefs[anAttrInRef] = anAttrList;
+ }
+ }
+ }
+ else { /// find attributes referenced to feature itself
+ theRefsToFeature.push_back(anAttr);
+ }
+ }
+ }
+}
+
+void SketchPlugin_Trim::updateRefFeatureConstraints(
+ const ResultPtr& theFeatureBaseResult,
+ const std::list<AttributePtr>& theRefsToFeature)
+{
+ std::list<AttributePtr>::const_iterator anIt = theRefsToFeature.begin(),
+ aLast = theRefsToFeature.end();
+ for (; anIt != aLast; anIt++) {
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIt);
+ if (aRefAttr.get())
+ aRefAttr->setObject(theFeatureBaseResult);
+ }
+}
+
+void SketchPlugin_Trim::updateRefAttConstraints(
+ const std::map<AttributePtr, std::list<AttributePtr> >& theBaseRefAttributes,
+ const std::set<std::pair<AttributePtr, AttributePtr> >& theModifiedAttributes,
+ std::set<FeaturePtr>& theFeaturesToDelete)
+{
+#ifdef DEBUG_TRIM
+ std::cout << "SketchPlugin_Trim::updateRefAttConstraints" << std::endl;
+#endif
+
+ std::set<std::pair<AttributePtr, AttributePtr> >::const_iterator
+ anIt = theModifiedAttributes.begin(), aLast = theModifiedAttributes.end();
+ for (; anIt != aLast; anIt++) {
+ AttributePtr anAttribute = anIt->first;
+
+ /// not found in references
+ if (theBaseRefAttributes.find(anAttribute) == theBaseRefAttributes.end())
+ continue;
+ std::list<AttributePtr> aRefAttributes = theBaseRefAttributes.at(anAttribute);
+ std::list<AttributePtr>::const_iterator aRefIt = aRefAttributes.begin(),
+ aRLast = aRefAttributes.end();
+
+ AttributePtr aNewAttribute = anIt->second;
+ for (; aRefIt != aRLast; aRefIt++) {
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*aRefIt);
+ if (aRefAttr.get()) {
+ if (aNewAttribute.get())
+ aRefAttr->setAttr(aNewAttribute);
+ else
+ theFeaturesToDelete.insert(ModelAPI_Feature::feature(aRefAttr->owner()));
+#ifdef DEBUG_TRIM
+ //FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->owner());
+ //std::cout << " -" << getFeatureInfo(aFeature) << std::endl;
+#endif
+ }
+ }
+ }
+}
+
+void SketchPlugin_Trim::trimLine(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theLastShapePoint,
+ std::set<AttributePoint2DPtr>& thePoints,
+ std::set<FeaturePtr>& theCreatedFeatures,
+ std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes)
+{
+ // Check the base objects are initialized.
+ AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ ObjectPtr aBaseObject = aBaseObjectAttr->value();
+ FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
+
+ /// points of trim
+ AttributePoint2DPtr aStartPointAttrOfBase, anEndPointAttrOfBase;
+ getFeaturePoints(aBaseFeature, aStartPointAttrOfBase, anEndPointAttrOfBase);
+
+ std::shared_ptr<GeomAPI_Pnt2d> aStartFeaturePoint = aStartPointAttrOfBase->pnt();
+ std::shared_ptr<GeomAPI_Pnt2d> aLastFeaturePoint = anEndPointAttrOfBase->pnt();
+
+ std::shared_ptr<GeomAPI_Pnt2d> aStartShapePoint = theStartShapePoint;
+ std::shared_ptr<GeomAPI_Pnt2d> aLastShapePoint = theLastShapePoint;
+ arrangePointsOnLine(aStartPointAttrOfBase, anEndPointAttrOfBase,
+ aStartShapePoint, aLastShapePoint);
+#ifdef DEBUG_TRIM
+ std::cout << "Arranged points (to build split between 1st and 2nd points:" << std::endl;
+ if (aStartShapePoint.get())
+ std::cout << "Start point: [" << aStartShapePoint->x() << ", " <<
+ aStartShapePoint->y() << "]" << std::endl;
+ std::cout << "1st point: [" << aStartFeaturePoint->x() << ", " <<
+ aStartFeaturePoint->y() << "]" << std::endl;
+ if (aLastShapePoint.get())
+ std::cout << "2st point: [" << aLastShapePoint->x() << ", " <<
+ aLastShapePoint->y() << "]" << std::endl;
+ std::cout << "End point: [" << aLastFeaturePoint->x() << ", " <<
+ aLastFeaturePoint->y() << "]" << std::endl;
+#endif
+
+ bool isStartPoint = !aStartShapePoint.get() || aStartFeaturePoint->isEqual(aStartShapePoint);
+ bool isLastPoint = !aLastShapePoint.get() || aLastFeaturePoint->isEqual(aLastShapePoint);
+ if (isStartPoint || isLastPoint) {
+ // result is one line: changed existing line
+ std::string aModifiedAttribute = isStartPoint ? SketchPlugin_Line::START_ID()
+ : SketchPlugin_Line::END_ID();
+ std::shared_ptr<GeomAPI_Pnt2d> aPoint;
+ if (aStartShapePoint.get() && aLastShapePoint.get())
+ aPoint = isStartPoint ? aLastShapePoint : aStartShapePoint;
+ else
+ aPoint = aStartShapePoint.get() ? aStartShapePoint : aLastShapePoint;
+
+ fillPointAttribute(aBaseFeature->attribute(aModifiedAttribute), aPoint);
+ theModifiedAttributes.insert(
+ std::make_pair(aBaseFeature->attribute(aModifiedAttribute), AttributePtr()));
+
+ thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
+ (aBaseFeature->attribute(aModifiedAttribute)));
+ }
+ else {
+ // result is two lines: start line point - start shape point, last shape point - last line point
+ // create second line
+ FeaturePtr anNewFeature = createLineFeature(aBaseFeature, aLastShapePoint, aLastFeaturePoint);
+ thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
+ (anNewFeature->attribute(SketchPlugin_Line::START_ID())));
+
+ std::string aModifiedAttribute = SketchPlugin_Line::END_ID();
+ theModifiedAttributes.insert(
+ std::make_pair(aBaseFeature->attribute(aModifiedAttribute),
+ anNewFeature->attribute(SketchPlugin_Line::END_ID())));
+
+ // modify base arc
+ fillPointAttribute(aBaseFeature->attribute(aModifiedAttribute), aStartShapePoint);
+
+ thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
+ (aBaseFeature->attribute(aModifiedAttribute)));
+
+ // Collinear constraint for lines
+ createConstraintForObjects(SketchPlugin_ConstraintCollinear::ID(),
+ getFeatureResult(aBaseFeature),
+ getFeatureResult(anNewFeature));
+
+ }
+}
+
+void SketchPlugin_Trim::trimArc(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theLastShapePoint,
+ std::set<AttributePoint2DPtr>& thePoints,
+ std::set<FeaturePtr>& theCreatedFeatures,
+ std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes)
+{
+ // Check the base objects are initialized.
+ AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ ObjectPtr aBaseObject = aBaseObjectAttr->value();
+ FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
+
+ /// points of trim
+ AttributePoint2DPtr aStartPointAttrOfBase, anEndPointAttrOfBase;
+ getFeaturePoints(aBaseFeature, aStartPointAttrOfBase, anEndPointAttrOfBase);
+
+ std::shared_ptr<GeomAPI_Pnt2d> aStartArcPoint = aStartPointAttrOfBase->pnt();
+ std::shared_ptr<GeomAPI_Pnt2d> aLastArcPoint = anEndPointAttrOfBase->pnt();
+
+ std::shared_ptr<GeomAPI_Pnt2d> aStartShapePoint = theStartShapePoint;
+ std::shared_ptr<GeomAPI_Pnt2d> aLastShapePoint = theLastShapePoint;
+ arrangePointsOnArc(aBaseFeature, aStartPointAttrOfBase, anEndPointAttrOfBase,
+ aStartShapePoint, aLastShapePoint);
+#ifdef DEBUG_TRIM
+ std::cout << "Arranged points (to build split between 1st and 2nd points:" << std::endl;
+ if (aStartShapePoint.get())
+ std::cout << "Start point: [" << aStartShapePoint->x() << ", " <<
+ aStartShapePoint->y() << "]" << std::endl;
+ std::cout << "1st point: [" << aStartArcPoint->x() << ", " <<
+ aStartArcPoint->y() << "]" << std::endl;
+ if (aLastShapePoint.get())
+ std::cout << "2st point: [" << aLastShapePoint->x() << ", " <<
+ aLastShapePoint->y() << "]" << std::endl;
+ std::cout << "End point: [" << aLastArcPoint->x() << ", " <<
+ aLastArcPoint->y() << "]" << std::endl;
+#endif
+
+ bool isStartPoint = !aStartShapePoint.get() || aStartArcPoint->isEqual(aStartShapePoint);
+ bool isLastPoint = !aLastShapePoint.get() || aLastArcPoint->isEqual(aLastShapePoint);
+ if (isStartPoint || isLastPoint) {
+ // result is one arc: changed existing arc
+ std::string aModifiedAttribute = isStartPoint ? SketchPlugin_Arc::START_ID()
+ : SketchPlugin_Arc::END_ID();
+ std::shared_ptr<GeomAPI_Pnt2d> aPoint;
+ if (aStartShapePoint.get() && aLastShapePoint.get())
+ aPoint = isStartPoint ? aLastShapePoint : aStartShapePoint;
+ else
+ aPoint = aStartShapePoint.get() ? aStartShapePoint : aLastShapePoint;
+
+ fillPointAttribute(aBaseFeature->attribute(aModifiedAttribute), aPoint);
+ theModifiedAttributes.insert(
+ std::make_pair(aBaseFeature->attribute(aModifiedAttribute), AttributePtr()));
+
+ thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
+ (aBaseFeature->attribute(aModifiedAttribute)));
+ }
+ else {
+ // result is two arcs: start arc point - start shape point, last shape point - last arc point
+ // create second arc
+ FeaturePtr anArcFeature = createArcFeature(aBaseFeature, aLastShapePoint, aLastArcPoint);
+ thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
+ (anArcFeature->attribute(SketchPlugin_Arc::START_ID())));
+
+ std::string aModifiedAttribute = SketchPlugin_Arc::END_ID();
+ theModifiedAttributes.insert(
+ std::make_pair(aBaseFeature->attribute(aModifiedAttribute),
+ anArcFeature->attribute(SketchPlugin_Arc::END_ID())));
+
+ // modify base arc
+ fillPointAttribute(aBaseFeature->attribute(aModifiedAttribute), aStartShapePoint);
+
+ thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
+ (aBaseFeature->attribute(aModifiedAttribute)));
+
+ // equal Radius constraint for arcs
+ createConstraintForObjects(SketchPlugin_ConstraintEqual::ID(),
+ getFeatureResult(aBaseFeature),
+ getFeatureResult(anArcFeature));
+ // coincident centers constraint
+ createConstraint(SketchPlugin_ConstraintCoincidence::ID(),
+ aBaseFeature->attribute(SketchPlugin_Arc::CENTER_ID()),
+ anArcFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
+ }
+}
+
+void SketchPlugin_Trim::trimCircle(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theLastShapePoint,
+ std::set<AttributePoint2DPtr>& thePoints,
+ std::set<FeaturePtr>& theCreatedFeatures,
+ std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes)
+{
+ // Check the base objects are initialized.
+ AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ ObjectPtr aBaseObject = aBaseObjectAttr->value();
+ FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
+
+ /// points of trim
+ AttributePoint2DPtr aStartPointAttrOfBase, anEndPointAttrOfBase;
+ getFeaturePoints(aBaseFeature, aStartPointAttrOfBase, anEndPointAttrOfBase);
+
+ /// trim feature
+ FeaturePtr anArcFeature = createArcFeature(aBaseFeature, theStartShapePoint, theLastShapePoint);
+
+ theModifiedAttributes.insert(
+ std::make_pair(aBaseFeature->attribute(SketchPlugin_Circle::CENTER_ID()),
+ anArcFeature->attribute(SketchPlugin_Arc::CENTER_ID())));
+
+ thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
+ (anArcFeature->attribute(SketchPlugin_Arc::START_ID())));
+ thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
+ (anArcFeature->attribute(SketchPlugin_Arc::END_ID())));
+}
+
+void SketchPlugin_Trim::arrangePointsOnLine(const AttributePoint2DPtr& theStartPointAttr,
+ const AttributePoint2DPtr& theEndPointAttr,
+ std::shared_ptr<GeomAPI_Pnt2d>& theFirstPoint,
+ std::shared_ptr<GeomAPI_Pnt2d>& theLastPoint) const
+{
+ if (!theFirstPoint.get() || !theLastPoint.get())
+ return;
+
+ // if first point is closer to last point, swap first and last values
+ if (theStartPointAttr->pnt()->distance(theFirstPoint) >
+ theStartPointAttr->pnt()->distance(theLastPoint)) {
+ std::shared_ptr<GeomAPI_Pnt2d> aTmpPoint = theFirstPoint;
+ theFirstPoint = theLastPoint;
+ theLastPoint = aTmpPoint;
+ }
+}
+
+void SketchPlugin_Trim::arrangePointsOnArc(const FeaturePtr& theArc,
+ const AttributePoint2DPtr& theStartPointAttr,
+ const AttributePoint2DPtr& theEndPointAttr,
+ std::shared_ptr<GeomAPI_Pnt2d>& theFirstPoint,
+ std::shared_ptr<GeomAPI_Pnt2d>& theSecondPoint) const
+{
+ if (!theFirstPoint.get() || !theSecondPoint.get())
+ return;
+
+ static const double anAngleTol = 1.e-12;
+
+ std::shared_ptr<GeomAPI_Pnt2d> aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theArc->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt();
+ bool isReversed = theArc->boolean(SketchPlugin_Arc::INVERSED_ID())->value();
+
+ // collect directions to each point
+ std::shared_ptr<GeomAPI_Dir2d> aStartDir(
+ new GeomAPI_Dir2d(theStartPointAttr->pnt()->xy()->decreased(aCenter->xy())));
+ std::shared_ptr<GeomAPI_Dir2d> aFirstPtDir(
+ new GeomAPI_Dir2d(theFirstPoint->xy()->decreased(aCenter->xy())));
+ std::shared_ptr<GeomAPI_Dir2d> aSecondPtDir(
+ new GeomAPI_Dir2d(theSecondPoint->xy()->decreased(aCenter->xy())));
+
+ // sort points by their angular values
+ double aFirstPtAngle = aStartDir->angle(aFirstPtDir);
+ double aSecondPtAngle = aStartDir->angle(aSecondPtDir);
+ double aPeriod = isReversed ? -2.0 * PI : 2.0 * PI;
+ if (fabs(aFirstPtAngle) > anAngleTol && isReversed == (aFirstPtAngle > 0.))
+ aFirstPtAngle += aPeriod;
+ if (fabs(aSecondPtAngle) > anAngleTol && isReversed == (aSecondPtAngle > 0.))
+ aSecondPtAngle += aPeriod;
+
+ if (fabs(aFirstPtAngle) > fabs(aSecondPtAngle)) {
+ std::shared_ptr<GeomAPI_Pnt2d> aTmpPoint = theFirstPoint;
+ theFirstPoint = theSecondPoint;
+ theSecondPoint = aTmpPoint;
+ }
+}
+
+void SketchPlugin_Trim::fillPointAttribute(const AttributePtr& theModifiedAttribute,
+ const std::shared_ptr<GeomAPI_Pnt2d>& thePoint)
+{
+ std::string anAttributeType = theModifiedAttribute->attributeType();
+ if (anAttributeType == GeomDataAPI_Point2D::typeId()) {
+ AttributePoint2DPtr aModifiedAttribute = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theModifiedAttribute);
+ aModifiedAttribute->setValue(thePoint);
+
+#ifdef DEBUG_TRIM
+ std::cout << "<fillPointAttribute> => Pnt2d - [" << thePoint->x() << ", " << thePoint->y() << "]" << std::endl;
+#endif
+ }
+}
+
+
+void SketchPlugin_Trim::fillAttribute(const AttributePtr& theModifiedAttribute,
+ const AttributePtr& theSourceAttribute)
+{
+ std::string anAttributeType = theModifiedAttribute->attributeType();
+ if (anAttributeType == GeomDataAPI_Point2D::typeId()) {
+ AttributePoint2DPtr aModifiedAttribute = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theModifiedAttribute);
+ AttributePoint2DPtr aSourceAttribute = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theSourceAttribute);
+
+ if (aModifiedAttribute.get() && aSourceAttribute.get())
+ aModifiedAttribute->setValue(aSourceAttribute->pnt());
+ }
+ else if (anAttributeType == ModelAPI_AttributeBoolean::typeId()) {
+ AttributeBooleanPtr aModifiedAttribute = std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>(
+ theModifiedAttribute);
+ AttributeBooleanPtr aSourceAttribute = std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>(
+ theSourceAttribute);
+
+ if (aModifiedAttribute.get() && aSourceAttribute.get())
+ aModifiedAttribute->setValue(aSourceAttribute->value());
+ }
+ else if (anAttributeType == ModelAPI_AttributeRefAttr::typeId()) {
+ AttributeRefAttrPtr aRefAttributeToFill = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ theModifiedAttribute);
+ AttributeRefAttrPtr aSourceRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ theSourceAttribute);
+ if (!aSourceRefAttr.get())
+ aRefAttributeToFill->setAttr(theSourceAttribute);
+ else {
+ if (aSourceRefAttr->isObject())
+ aRefAttributeToFill->setObject(aSourceRefAttr->object());
+ else
+ aRefAttributeToFill->setAttr(aSourceRefAttr->attr());
+ }
+ }
+}
+
+FeaturePtr SketchPlugin_Trim::createLineFeature(const FeaturePtr& theBaseFeature,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theFirstPoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theSecondPoint)
+{
+ FeaturePtr aFeature;
+ SketchPlugin_Sketch* aSketch = sketch();
+ if (!aSketch || !theBaseFeature.get())
+ return aFeature;
+
+ aFeature = aSketch->addFeature(SketchPlugin_Line::ID());
+
+ fillPointAttribute(aFeature->attribute(SketchPlugin_Line::START_ID()), theFirstPoint);
+ fillPointAttribute(aFeature->attribute(SketchPlugin_Line::END_ID()), theSecondPoint);
+
+ fillAttribute(aFeature->attribute(SketchPlugin_SketchEntity::AUXILIARY_ID()),
+ theBaseFeature->attribute(SketchPlugin_SketchEntity::AUXILIARY_ID()));
+
+ aFeature->execute(); // to obtain result
+
+ return aFeature;
+}
+
+
+FeaturePtr SketchPlugin_Trim::createArcFeature(const FeaturePtr& theBaseFeature,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theFirstPoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theSecondPoint)
+{
+ FeaturePtr aFeature;
+ SketchPlugin_Sketch* aSketch = sketch();
+ if (!aSketch || !theBaseFeature.get())
+ return aFeature;
+
+ std::string aCenterAttributeId;
+ if (theBaseFeature->getKind() == SketchPlugin_Arc::ID())
+ aCenterAttributeId = SketchPlugin_Arc::CENTER_ID();
+ else if (theBaseFeature->getKind() == SketchPlugin_Circle::ID())
+ aCenterAttributeId = SketchPlugin_Circle::CENTER_ID();
+
+ if (aCenterAttributeId.empty())
+ return aFeature;
+
+ aFeature = aSketch->addFeature(SketchPlugin_Arc::ID());
+ // update fillet arc: make the arc correct for sure, so, it is not needed to process
+ // the "attribute updated"
+ // by arc; moreover, it may cause cyclicity in hte mechanism of updater
+ bool aWasBlocked = aFeature->data()->blockSendAttributeUpdated(true);
+
+ aFeature->string(SketchPlugin_Arc::ARC_TYPE())->setValue(
+ SketchPlugin_Arc::ARC_TYPE_CENTER_START_END());
+
+ fillAttribute(aFeature->attribute(SketchPlugin_Arc::CENTER_ID()),
+ theBaseFeature->attribute(aCenterAttributeId));
+ fillPointAttribute(aFeature->attribute(SketchPlugin_Arc::START_ID()), theFirstPoint);
+ fillPointAttribute(aFeature->attribute(SketchPlugin_Arc::END_ID()), theSecondPoint);
+
+ fillAttribute(aFeature->attribute(SketchPlugin_SketchEntity::AUXILIARY_ID()),
+ theBaseFeature->attribute(SketchPlugin_SketchEntity::AUXILIARY_ID()));
+
+ /// fill referersed state of created arc as it is on the base arc
+ if (theBaseFeature->getKind() == SketchPlugin_Arc::ID()) {
+ bool aReversed = theBaseFeature->boolean(SketchPlugin_Arc::INVERSED_ID())->value();
+ aFeature->boolean(SketchPlugin_Arc::INVERSED_ID())->setValue(aReversed);
+ }
+ aFeature->execute(); // to obtain result
+ aFeature->data()->blockSendAttributeUpdated(aWasBlocked);
+
+ return aFeature;
+}
+
+FeaturePtr SketchPlugin_Trim::createConstraint(const std::string& theConstraintId,
+ const AttributePtr& theFirstAttribute,
+ const AttributePtr& theSecondAttribute)
+{
+ FeaturePtr aConstraint = sketch()->addFeature(theConstraintId);
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
+ aRefAttr->setAttr(theFirstAttribute);
+
+ aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
+ aRefAttr->setAttr(theSecondAttribute);
+
+#ifdef DEBUG_TRIM
+ std::cout << "<createConstraint to attribute> :"
+ << "first attribute - " << theFirstAttribute->id()
+ << "second attribute - " << theSecondAttribute->id()
+ << std::endl;
+#endif
+
+ return aConstraint;
+}
+
+FeaturePtr SketchPlugin_Trim::createConstraint(const std::string& theConstraintId,
+ const AttributePtr& theFirstAttribute,
+ const ObjectPtr& theSecondObject)
+{
+ FeaturePtr aConstraint = sketch()->addFeature(theConstraintId);
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
+ aRefAttr->setAttr(theFirstAttribute);
+
+ aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
+ aRefAttr->setObject(theSecondObject);
+
+#ifdef DEBUG_TRIM
+ std::cout << "<createConstraint to attribute> :"
+ << "first attribute - " << theFirstAttribute->id()
+ << "second object - " << ModelAPI_Feature::feature(theSecondObject)->getKind()
+ << std::endl;
+#endif
+
+ return aConstraint;
+}
+
+FeaturePtr SketchPlugin_Trim::createConstraintForObjects(
+ const std::string& theConstraintId,
+ const ObjectPtr& theFirstObject,
+ const ObjectPtr& theSecondObject)
+{
+ FeaturePtr aConstraint = sketch()->addFeature(theConstraintId);
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
+ aRefAttr->setObject(theFirstObject);
+
+ aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
+ aRefAttr->setObject(theSecondObject);
+
+ return aConstraint;
+}
+
+std::shared_ptr<ModelAPI_Result> SketchPlugin_Trim::getFeatureResult(
+ const std::shared_ptr<ModelAPI_Feature>& theFeature)
+{
+ std::shared_ptr<ModelAPI_Result> aResult;
+
+ std::string aFeatureKind = theFeature->getKind();
+ if (aFeatureKind == SketchPlugin_Line::ID())
+ aResult = theFeature->firstResult();
+ else if (aFeatureKind == SketchPlugin_Arc::ID())
+ aResult = theFeature->lastResult();
+ else if (aFeatureKind == SketchPlugin_Circle::ID())
+ aResult = theFeature->lastResult();
+
+ return aResult;
+}
+
+//********************************************************************
+bool SketchPlugin_Trim::useGraphicIntersection() const
+{
+ return true;
+}
+
+//********************************************************************
+void SketchPlugin_Trim::fillObjectShapes(const ObjectPtr& theObject)
+{
+ PointToRefsMap aPointsInfo;
+
+ std::set<std::shared_ptr<GeomAPI_Shape> > aShapes;
+ std::map<std::shared_ptr<GeomAPI_Pnt>,
+ std::list< AttributePoint2DPtr > > aPointToAttributes;
+ std::map<std::shared_ptr<GeomAPI_Pnt>,
+ std::list< ObjectPtr > > aPointToObjects;
+
+ std::set<AttributePoint2DPtr > aRefAttributes;
+ // current feature
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
+ std::set<ResultPtr> anEdgeShapes;
+ // edges on feature
+ ModelAPI_Tools::shapesOfType(aFeature, GeomAPI_Shape::EDGE, anEdgeShapes);
+ if (!anEdgeShapes.empty()) {
+ GeomShapePtr aFeatureShape = (*anEdgeShapes.begin())->shape();
+
+ // coincidences to the feature
+ ModelGeomAlgo_Point2D::getPointsOfReference(aFeature, SketchPlugin_ConstraintCoincidence::ID(),
+ aRefAttributes, SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID());
+ // layed on feature coincidences to divide it on several shapes
+ SketchPlugin_Sketch* aSketch = sketch();
+ std::shared_ptr<ModelAPI_Data> aData = aSketch->data();
+ std::shared_ptr<GeomDataAPI_Point> aC = std::dynamic_pointer_cast<GeomDataAPI_Point>(
+ aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
+ std::shared_ptr<GeomDataAPI_Dir> aX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+ aData->attribute(SketchPlugin_Sketch::DIRX_ID()));
+ std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+ aData->attribute(SketchPlugin_Sketch::NORM_ID()));
+ std::shared_ptr<GeomAPI_Dir> aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir())));
+
+ ModelGeomAlgo_Point2D::getPointsInsideShape(aFeatureShape, aRefAttributes, aC->pnt(),
+ aX->dir(), aY, aPointsInfo);
+
+ // intersection points
+ if (useGraphicIntersection()) {
+ std::list<FeaturePtr> aFeatures;
+ for (int i = 0; i < aSketch->numberOfSubs(); i++) {
+ FeaturePtr aFeature = aSketch->subFeature(i);
+ if (aFeature.get())
+ aFeatures.push_back(aFeature);
+ }
+ ModelGeomAlgo_Point2D::getPointsIntersectedShape(aFeature, aFeatures, aPointsInfo);
+ }
+ GeomAlgoAPI_ShapeTools::splitShape(aFeatureShape, aPointsInfo, aShapes);
+ }
+ myObjectToPoints[theObject] = aPointsInfo;
+ myCashedShapes[theObject] = aShapes;
+}
+
+//********************************************************************
+void SketchPlugin_Trim::attributeChanged(const std::string& theID)
+{
+ //data()->addAttribute(SketchPlugin_Trim::BASE_OBJECT(), ModelAPI_AttributeReference::typeId());
+ if (theID == SketchPlugin_Trim::BASE_OBJECT()) {
+ bool isValidAttribute = false;
+ // feature for trim
+ AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::BASE_OBJECT()));
+ ObjectPtr aBaseObject = aBaseObjectAttr->value();
+ if (aBaseObject.get()) {
+ FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
+ // point on feature
+ AttributePoint2DPtr aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ data()->attribute(ENTITY_POINT()));
+ std::shared_ptr<GeomAPI_Pnt2d> anAttributePnt2d = aPoint->pnt();
+ std::shared_ptr<GeomAPI_Pnt> anAttributePnt = sketch()->to3D(anAttributePnt2d->x(), anAttributePnt2d->y());
+
+ if (myCashedShapes.find(aBaseObject) == myCashedShapes.end())
+ fillObjectShapes(aBaseObject);
+
+ const std::set<GeomShapePtr>& aShapes = myCashedShapes[aBaseObject];
+ isValidAttribute = !aShapes.empty();
+
+ if (!isValidAttribute) {
+ bool aWasBlocked = data()->blockSendAttributeUpdated(true);
+ aBaseObjectAttr->setValue(ObjectPtr());
+ data()->blockSendAttributeUpdated(aWasBlocked);
+ }
+ }
+ }
+}
--- /dev/null
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
+
+// File: SketchPlugin_Trim.h
+// Created: 22 Feb 2017
+// Author: Natalia ERMOLAEVA
+
+#ifndef SketchPlugin_Trim_H_
+#define SketchPlugin_Trim_H_
+
+#include "SketchPlugin.h"
+#include <SketchPlugin_Sketch.h>
+#include "SketchPlugin_ConstraintBase.h"
+
+class GeomDataAPI_Point2D;
+class ModelAPI_Feature;
+class ModelAPI_Result;
+
+typedef std::pair<std::string, std::shared_ptr<GeomDataAPI_Point2D> > IdToPointPair;
+
+/** \class SketchPlugin_Trim
+ * \ingroup Plugins
+ * \brief Feature for creation of a new constraint trimming object. Entities for split:
+ */
+class SketchPlugin_Trim : public SketchPlugin_Feature, public GeomAPI_IPresentable
+{
+ public:
+ /// Split constraint kind
+ inline static const std::string& ID()
+ {
+ static const std::string MY_TRIM_ID("SketchTrim");
+ return MY_TRIM_ID;
+ }
+ /// \brief Returns the kind of a feature
+ SKETCHPLUGIN_EXPORT virtual const std::string& getKind()
+ {
+ static std::string MY_KIND = SketchPlugin_Trim::ID();
+ return MY_KIND;
+ }
+
+ /// The value parameter for the constraint
+ inline static const std::string& BASE_OBJECT()
+ {
+ static const std::string MY_CONSTRAINT_BASE_OBJECT("BaseObject");
+ return MY_CONSTRAINT_BASE_OBJECT;
+ }
+
+ /// Start 2D point of the split segment
+ inline static const std::string& ENTITY_POINT()
+ {
+ static const std::string MY_ENTITY_POINT("ConstraintEntityPoint");
+ return MY_ENTITY_POINT;
+ }
+
+ /// \brief Creates a new part document if needed
+ SKETCHPLUGIN_EXPORT virtual void execute();
+
+ /// \brief Request for initialization of data model of the feature: adding all attributes
+ SKETCHPLUGIN_EXPORT virtual void initAttributes();
+
+ /// Reimplemented from ModelAPI_Feature::isMacro()
+ /// \returns true
+ SKETCHPLUGIN_EXPORT virtual bool isMacro() const;
+
+ /// Reimplemented from ModelAPI_Feature::isPreviewNeeded(). Returns false.
+ /// This is necessary to perform execute only by apply the feature
+ SKETCHPLUGIN_EXPORT virtual bool isPreviewNeeded() const { return false; }
+
+ /// Called on change of any argument-attribute of this object
+ /// \param theID identifier of changed attribute
+ SKETCHPLUGIN_EXPORT virtual void attributeChanged(const std::string& theID);
+
+ /// \brief Use plugin manager for features creation
+ SketchPlugin_Trim();
+
+ /// Returns the AIS preview
+ SKETCHPLUGIN_EXPORT virtual AISObjectPtr getAISObject(AISObjectPtr thePrevious);
+
+ /// Moves the feature : Empty
+ SKETCHPLUGIN_EXPORT virtual void move(const double theDeltaX, const double theDeltaY) {};
+
+private:
+ /// Returns geom point attribute of the feature bounds. It processes line or arc.
+ /// For circle feature, the result attributes are null
+ /// \param theFeature a source feature
+ /// \param theStartPointAttr an out attribute to start point
+ /// \param theStartPointAttr an out attribute to end point
+ void getFeaturePoints(const FeaturePtr& theFeature,
+ std::shared_ptr<GeomDataAPI_Point2D>& theStartPointAttr,
+ std::shared_ptr<GeomDataAPI_Point2D>& theEndPointAttr);
+
+ /// Obtains those constraints of the feature that should be modified. output maps contain
+ /// point of coincidence and attribute id to be modified after split
+ /// \param theFeaturesToDelete [out] constrains that will be deleted after split
+ /// \param theFeaturesToUpdate [out] constrains that will be updated after split
+ void getConstraints(std::set<std::shared_ptr<ModelAPI_Feature>>& theFeaturesToDelete,
+ std::set<std::shared_ptr<ModelAPI_Feature>>& theFeaturesToUpdate);
+
+ /// Obtains references to feature point attributes and to feature,
+ /// e.g. for feature line: 1st container is
+ /// <1st line point, list<entity_a in distance, entity_b in parallel> >
+ /// <2nd line point, list<> >
+ /// for feature circle 2nd container is <entity_a in Radius, entity_b in equal, ...>
+ /// \param theFeature an investigated feature
+ /// \param theRefs a container of list of referenced attributes
+ void getRefAttributes(const FeaturePtr& theFeature,
+ std::map<AttributePtr, std::list<AttributePtr> >& theRefs,
+ std::list<AttributePtr>& theRefsToFeature);
+
+ /// Move constraints from base feature to given feature
+ /// \param theFeature a base feature
+ /// \param theRefsToFeature list of attributes referenced to base feature
+ void updateRefFeatureConstraints(const std::shared_ptr<ModelAPI_Result>& theFeatureBaseResult,
+ const std::list<AttributePtr>& theRefsToFeature);
+
+ /// Move constraints from attribute of base feature to attribute after modification
+ /// \param theBaseRefAttributes container of references to the attributes of base feature
+ /// \param theModifiedAttributes container of attributes placed instead of base attributes
+ /// at the same place
+ void updateRefAttConstraints(
+ const std::map<AttributePtr, std::list<AttributePtr> >& theBaseRefAttributes,
+ const std::set<std::pair<AttributePtr, AttributePtr> >& theModifiedAttributes,
+ std::set<std::shared_ptr<ModelAPI_Feature>>& theFeaturesToDelete);
+
+// /// Make the base object is splitted by the point attributes
+// /// \param theSplitFeature a result split feature
+// /// \param theBeforeFeature a feature between start point and the 1st point of split feature
+// /// \param theAfterFeature a feature between last point of split feature and the end point
+// /// \param thePoints a list of points where coincidences will be build
+// /// \param theCreatedFeatures a container of created features
+// /// \param theModifiedAttributes a container of attribute on base
+// /// feature to attribute on new feature
+ void trimLine(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theLastShapePoint,
+ std::set<std::shared_ptr<GeomDataAPI_Point2D> >& thePoints,
+ std::set<std::shared_ptr<ModelAPI_Feature>>& theCreatedFeatures,
+ std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes);
+
+ /// Make the base object is splitted by the point attributes
+ /// \param theSplitFeature a result split feature
+ /// \param theBeforeFeature a feature between start point and the 1st point of split feature
+ /// \param theAfterFeature a feature between last point of split feature and the end point
+ /// \param thePoints a list of points where coincidences will be build
+ /// \param theCreatedFeatures a container of created features
+ void trimArc(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theLastShapePoint,
+ std::set<std::shared_ptr<GeomDataAPI_Point2D> >& thePoints,
+ std::set<std::shared_ptr<ModelAPI_Feature>>& theCreatedFeatures,
+ std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes);
+
+ /// Make the base object is splitted by the point attributes
+ /// \param theSplitFeature a result split feature
+ /// \param theBeforeFeature a feature between start point and the 1st point of split feature
+ /// \param theAfterFeature a feature between last point of split feature and the end point
+ /// \param thePoints a list of points where coincidences will be build
+ /// \param theCreatedFeatures a container of created features
+ void trimCircle(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theLastShapePoint,
+ std::set<std::shared_ptr<GeomDataAPI_Point2D> >& thePoints,
+ std::set<std::shared_ptr<ModelAPI_Feature>>& theCreatedFeatures,
+ std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes);
+
+ /// Correct the first and the second point to provide condition that the first is closer to
+ /// the start point and the second point - to the last end of current segment. To rearrange
+ /// them if this condition is not satisfied.
+ /// \param theStartPointAttr a start point of a segment
+ /// \param theEndPointAttr an end point of a segment
+ /// \param theFirstPoint a start point of a segment
+ /// \param theSecondPoint an end point of a segment
+ void arrangePointsOnLine(const std::shared_ptr<GeomDataAPI_Point2D>& theStartPointAttr,
+ const std::shared_ptr<GeomDataAPI_Point2D>& theEndPointAttr,
+ std::shared_ptr<GeomAPI_Pnt2d>& theFirstPoint,
+ std::shared_ptr<GeomAPI_Pnt2d>& theSecondPoint) const;
+
+ /// Correct the first and the second point to provide condition that the first is closer to
+ /// the start point and the second point - to the last end of current segment. To rearrange
+ /// them if this condition is not satisfied.
+ /// \param theArc an arc to be split
+ /// \param theStartPointAttr a start point of a segment
+ /// \param theEndPointAttr an end point of a segment
+ /// \param theFirstPoint a start point of a segment
+ /// \param theSecondPoint an end point of a segment
+ void arrangePointsOnArc(const FeaturePtr& theArc,
+ const std::shared_ptr<GeomDataAPI_Point2D>& theStartPointAttr,
+ const std::shared_ptr<GeomDataAPI_Point2D>& theEndPointAttr,
+ std::shared_ptr<GeomAPI_Pnt2d>& theFirstPoint,
+ std::shared_ptr<GeomAPI_Pnt2d>& theSecondPoint) const;
+
+ /// Fill attribute by value of another attribute. It processes only Point 2D attributes.
+ /// \param theModifiedAttribute an attribute of GeomDataAPI_Point2D on feature to be modified
+ /// \param theSourceAttribute an attribute of GeomDataAPI_Point2D to obtain data
+ void fillAttribute(const AttributePtr& theModifiedAttribute,
+ const AttributePtr& theSourceAttribute);
+
+ /// Fill attribute by value of another attribute. It processes only Point 2D attributes.
+ /// \param theModifiedAttribute an attribute of GeomDataAPI_Point2D on feature to be modified
+ /// \param thePoint a point value
+ void fillPointAttribute(const AttributePtr& theModifiedAttribute,
+ const std::shared_ptr<GeomAPI_Pnt2d>& thePoint);
+
+ /// Creates a line feature filled by center of base feature and given points
+ /// \param theBaseFeature another arc feature
+ /// \param theFirstAttribute an attribute with coordinates for the start point
+ /// \param theSecondAttribute an attribute with coordinates for the end point
+ FeaturePtr createLineFeature(const FeaturePtr& theBaseFeature,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theFirstPoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theSecondPoint);
+
+ /// Creates an arc feature filled by center of base feature and given points
+ /// \param theBaseFeature another arc feature
+ /// \param theFirstAttribute an attribute with coordinates for the start point
+ /// \param theSecondAttribute an attribute with coordinates for the end point
+ FeaturePtr createArcFeature(const FeaturePtr& theBaseFeature,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theFirstPoint,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theSecondPoint);
+
+ /// Add feature coincidence constraint between given attributes
+ /// \param theConstraintId a constraint index
+ /// \param theFirstAttribute an attribute of further coincidence
+ /// \param theSecondAttribute an attribute of further coincidence
+ std::shared_ptr<ModelAPI_Feature> createConstraint(const std::string& theConstraintId,
+ const std::shared_ptr<ModelAPI_Attribute>& theFirstAttribute,
+ const std::shared_ptr<ModelAPI_Attribute>& theSecondAttribute);
+
+ /// Add feature coincidence constraint between given attributes
+ /// \param theConstraintId a constraint index
+ /// \param theFirstAttribute an attribute of further coincidence
+ /// \param theSecondObject an object of further coincidence
+ std::shared_ptr<ModelAPI_Feature> createConstraint(const std::string& theConstraintId,
+ const std::shared_ptr<ModelAPI_Attribute>& theFirstAttribute,
+ const std::shared_ptr<ModelAPI_Object>& theSecondObject);
+
+ /// Add feature coincidence constraint between given attributes
+ /// \param theConstraintId a constraint index
+ /// \param theFirstAttribute an attribute of further coincidence
+ /// \param theFirstAttribute an attribute of further coincidence
+ std::shared_ptr<ModelAPI_Feature> createConstraintForObjects(const std::string& theConstraintId,
+ const std::shared_ptr<ModelAPI_Object>& theFirstObject,
+ const std::shared_ptr<ModelAPI_Object>& theSecondObject);
+
+ /// Result result of the feature to build constraint with. For arc, circle it is an edge result.
+ /// \param theFeature a feature
+ /// \return result object
+ std::shared_ptr<ModelAPI_Result> getFeatureResult(
+ const std::shared_ptr<ModelAPI_Feature>& theFeature);
+
+private:
+ bool useGraphicIntersection() const;
+
+ void fillObjectShapes(const ObjectPtr& theObject);
+
+ void findShapePoints(std::shared_ptr<GeomAPI_Pnt>& aStartPoint,
+ std::shared_ptr<GeomAPI_Pnt>& aLastPoint);
+
+ std::shared_ptr<GeomAPI_Pnt2d> convertPoint(const std::shared_ptr<GeomAPI_Pnt>& thePoint);
+
+private:
+ std::map<ObjectPtr, std::set<GeomShapePtr> > myCashedShapes;
+
+ typedef std::map<std::shared_ptr<GeomAPI_Pnt>,
+ std::pair<std::list<std::shared_ptr<GeomDataAPI_Point2D> >,
+ std::list<std::shared_ptr<ModelAPI_Object> > > > PointToRefsMap;
+
+ std::map<ObjectPtr, PointToRefsMap> myObjectToPoints;
+};
+
+#endif
aKind == SketchPlugin_Arc::ID() ||
aKind == SketchPlugin_Circle::ID()) {
- std::set<GeomShapePtr> anEdgeShapes;
+ std::set<ResultPtr> anEdgeShapes;
ModelAPI_Tools::shapesOfType(anAttrFeature, GeomAPI_Shape::EDGE, anEdgeShapes);
if (anEdgeShapes.empty() || anEdgeShapes.size() > 1 /*there case has not existed yet*/)
return aValid;
SketchPlugin_ConstraintCoincidence::ID(),
aRefAttributes, SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID());
- GeomShapePtr anAttrShape = *anEdgeShapes.begin();
+ GeomShapePtr anAttrShape = (*anEdgeShapes.begin())->shape();
std::shared_ptr<SketchPlugin_Feature> aSFeature =
std::dynamic_pointer_cast<SketchPlugin_Feature>(anAttrFeature);
SketchPlugin_Sketch* aSketch = aSFeature->sketch();
aData->attribute(SketchPlugin_Sketch::NORM_ID()));
std::shared_ptr<GeomAPI_Dir> aDirY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir())));
- std::list<std::shared_ptr<GeomAPI_Pnt> > aPoints;
- std::map<std::shared_ptr<GeomDataAPI_Point2D>, std::shared_ptr<GeomAPI_Pnt> >
- aPointToAttributes;
+ typedef std::map<std::shared_ptr<GeomAPI_Pnt>,
+ std::pair<std::list<std::shared_ptr<GeomDataAPI_Point2D> >,
+ std::list<std::shared_ptr<ModelAPI_Object> > > > PointToRefsMap;
+ PointToRefsMap aPointsInfo;
+
+ //std::list<std::shared_ptr<GeomAPI_Pnt> > aPoints;
+ //std::map<std::shared_ptr<GeomDataAPI_Point2D>, std::shared_ptr<GeomAPI_Pnt> >
+ // aPointToAttributes;
+ //std::map<std::shared_ptr<GeomAPI_Pnt>,
+ // std::list< std::shared_ptr<GeomDataAPI_Point2D> > > aPointToAttributes;
ModelGeomAlgo_Point2D::getPointsInsideShape(anAttrShape, aRefAttributes, aC->pnt(),
- aX->dir(), aDirY, aPoints, aPointToAttributes);
+ aX->dir(), aDirY, aPointsInfo);//aPoints, aPointToAttributes);
- int aCoincidentToFeature = (int)aPoints.size();
+ int aCoincidentToFeature = (int)aPointsInfo.size();//aPoints.size();
if (aKind == SketchPlugin_Circle::ID())
aValid = aCoincidentToFeature >= 2;
else
--- /dev/null
+from salome.shaper import model
+
+from ModelAPI import *
+from GeomDataAPI import *
+from salome.shaper import geom
+import math
+
+TOLERANCE = 1.e-7
+
+SketchPointId = 'SketchPoint'
+SketchLineId = 'SketchLine'
+SketchArcId = 'SketchArc'
+SketchCircleId = 'SketchCircle'
+SketchConstraintCoincidenceId = 'SketchConstraintCoincidence'
+SketchConstraintParallelId = 'SketchConstraintParallel'
+SketchConstraintTangentId = 'SketchConstraintTangent'
+SketchConstraintEqualId = 'SketchConstraintEqual'
+
+model.begin()
+partSet = model.moduleDocument()
+Part_1 = model.addPart(partSet)
+Part_1_doc = Part_1.document()
+
+# Test1:begin split on circle with coincident point and intersection line : smaller part
+Sketch_1 = model.addSketch(Part_1_doc, model.defaultPlane("XOY"))
+SketchCircle_1_1 = Sketch_1.addCircle(50, 50, 20)
+SketchLine_1_1 = Sketch_1.addLine(50, 30, 100, 30)
+SketchLine_1_2 = Sketch_1.addLine(60, 50, 100, 30)
+
+SketchConstraintCoincidence_1_1 = Sketch_1.setCoincident(SketchLine_1_1.startPoint(), SketchCircle_1_1.results()[1])
+SketchConstraintCoincidence_1_2 = Sketch_1.setCoincident(SketchLine_1_1.endPoint(), SketchLine_1_2.endPoint())
+GeomPoint_1_1 = geom.Pnt2d(60, 35)
+
+#check number of features before trim
+Sketch_1_feature = featureToCompositeFeature(Sketch_1.feature())
+idList_before_1 = []
+for index in range(Sketch_1_feature.numberOfSubs()):
+ idList_before_1.append(Sketch_1_feature.subFeature(index).getKind())
+assert(idList_before_1.count(SketchCircleId) == 1)
+assert(idList_before_1.count(SketchArcId) == 0)
+assert(idList_before_1.count(SketchLineId) == 2)
+assert(idList_before_1.count(SketchConstraintCoincidenceId) == 2)
+
+#perform trim
+SketchTrim_1_1 = Sketch_1.addTrim(SketchCircle_1_1, GeomPoint_1_1)
+SketchTrim_1_1.execute()
+model.do()
+
+#check number of features after trim
+SketchFeatures = featureToCompositeFeature(Sketch_1.feature())
+idList_after_1 = []
+for SubIndex in range(SketchFeatures.numberOfSubs()):
+ SubFeature = SketchFeatures.subFeature(SubIndex)
+ idList_after_1.append(SubFeature.getKind())
+ if SubFeature.getKind() == SketchArcId:
+ ArcFeature_1 = SubFeature
+
+
+assert(idList_after_1.count(SketchCircleId) == 0)
+assert(idList_after_1.count(SketchArcId) == 1)
+assert(idList_after_1.count(SketchLineId) == 2)
+assert(idList_after_1.count(SketchConstraintCoincidenceId) == 3)
+
+#test created arc: it is not inversed, has coincidence to end line point
+anInversed_1 = ArcFeature_1.boolean("InversedArc").value()
+assert(anInversed_1 == False)
+ArcPoint_1 = geomDataAPI_Point2D(ArcFeature_1.attribute("ArcEndPoint"))
+LinePoint_1 = geomDataAPI_Point2D(SketchLine_1_1.startPoint())
+aDistance_1 = math.hypot(LinePoint_1.x() - ArcPoint_1.x(), LinePoint_1.y() - ArcPoint_1.y())
+#print "Distance " + repr(aDistance)
+assert (math.fabs(aDistance_1) <= TOLERANCE)
+# Test1:end
+
+
+# Test2: split on circle with coincident point and intersection line : largest part
+Sketch_2 = model.addSketch(Part_1_doc, model.defaultPlane("XOY"))
+move_test_delta_y = 100
+move_test_delta_x = 0
+SketchCircle_2_1 = Sketch_2.addCircle(50, 50 + move_test_delta_y, 20)
+SketchLine_2_1 = Sketch_2.addLine(50, 30 + move_test_delta_y, 100, 30 + move_test_delta_y)
+SketchLine_2_2 = Sketch_2.addLine(60, 50 + move_test_delta_y, 100, 30 + move_test_delta_y)
+
+SketchConstraintCoincidence_2_1 = Sketch_2.setCoincident(SketchLine_2_1.startPoint(), SketchCircle_2_1.results()[1])
+SketchConstraintCoincidence_2_2 = Sketch_2.setCoincident(SketchLine_2_1.endPoint(), SketchLine_2_2.endPoint())
+GeomPoint_2_1 = geom.Pnt2d(50, 75 + move_test_delta_y)
+
+#check number of features before trim
+Sketch_2_feature = featureToCompositeFeature(Sketch_2.feature())
+idList_before_2 = []
+for index in range(Sketch_2_feature.numberOfSubs()):
+ idList_before_2.append(Sketch_2_feature.subFeature(index).getKind())
+assert(idList_before_2.count(SketchCircleId) == 1)
+assert(idList_before_2.count(SketchArcId) == 0)
+assert(idList_before_2.count(SketchLineId) == 2)
+assert(idList_before_2.count(SketchConstraintCoincidenceId) == 2)
+
+#perform trim
+SketchTrim_2_1 = Sketch_2.addTrim(SketchCircle_2_1, GeomPoint_2_1)
+SketchTrim_2_1.execute()
+model.do()
+
+#check number of features after trim
+SketchFeatures = featureToCompositeFeature(Sketch_2.feature())
+idList_after_2 = []
+for SubIndex in range(SketchFeatures.numberOfSubs()):
+ SubFeature = SketchFeatures.subFeature(SubIndex)
+ idList_after_2.append(SubFeature.getKind())
+ if SubFeature.getKind() == SketchArcId:
+ ArcFeature_2 = SubFeature
+
+
+assert(idList_after_2.count(SketchCircleId) == 0)
+assert(idList_after_2.count(SketchArcId) == 1)
+assert(idList_after_2.count(SketchLineId) == 2)
+assert(idList_after_2.count(SketchConstraintCoincidenceId) == 3)
+
+#test created arc : it is not inversed, has coincidence to start line point
+anInversed_2 = ArcFeature_2.boolean("InversedArc").value()
+assert(anInversed_2 == False)
+ArcPoint_2 = geomDataAPI_Point2D(ArcFeature_2.attribute("ArcStartPoint"))
+LinePoint_2 = geomDataAPI_Point2D(SketchLine_2_1.startPoint())
+aDistance_2 = math.hypot(LinePoint_2.x() - ArcPoint_2.x(), LinePoint_2.y() - ArcPoint_2.y())
+#print "Distance " + repr(aDistance_2)
+assert (math.fabs(aDistance_2) <= TOLERANCE)
+# Test2:end
+
+model.end()
+
+#assert(model.checkPythonDump())
<group id="Linear geometry">
<feature
id="Sketch"
- nested="SketchPoint SketchIntersectionPoint SketchLine SketchCircle SketchArc SketchRectangle SketchProjection SketchConstraintLength SketchConstraintRadius SketchConstraintDistance SketchConstraintParallel SketchConstraintPerpendicular SketchConstraintRigid SketchConstraintHorizontal SketchConstraintVertical SketchConstraintEqual SketchConstraintTangent SketchConstraintFillet SketchConstraintSplit SketchConstraintCoincidence SketchConstraintMirror SketchConstraintAngle SketchMultiRotation SketchMultiTranslation SketchConstraintCollinear SketchConstraintMiddle"
+ nested="SketchPoint SketchIntersectionPoint SketchLine SketchCircle SketchArc
+ SketchRectangle
+ SketchProjection
+ SketchConstraintLength SketchConstraintRadius SketchConstraintDistance
+ SketchConstraintParallel SketchConstraintPerpendicular
+ SketchConstraintRigid SketchConstraintHorizontal SketchConstraintVertical
+ SketchConstraintEqual SketchConstraintTangent
+ SketchConstraintFillet SketchConstraintSplit SketchTrim
+ SketchConstraintCoincidence
+ SketchConstraintMirror SketchConstraintAngle
+ SketchMultiRotation SketchMultiTranslation
+ SketchConstraintCollinear SketchConstraintMiddle"
when_nested="accept abort"
title="Sketch"
tooltip="Create sketch"
<validator id="PartSet_FilletSelection"/>
</feature>
<!-- SketchConstraintSplit -->
- <feature id="SketchConstraintSplit" title="Split" tooltip="Create constraints defining split of linear segment, arc or circle" icon="icons/Sketch/split.png">
+ <feature id="SketchConstraintSplit" title="Split"
+ tooltip="Cut selected segment arc or circle on existing coincident points"
+ icon="icons/Sketch/split.png">
<sketch_sub_shape_selector
id="ConstraintValue"
label="Split feature"
tooltip="Select feature for split"
shape_types="edge"
- use_external="false">
+ use_external="false"
+ use_graphic_intersection="false">
<validator id="SketchPlugin_SplitValidator"/>
</sketch_sub_shape_selector>
<validator id="PartSet_SplitSelection"/>
</feature>
+ <!-- SketchTrim -->
+ <feature id="SketchTrim" title="Trim"
+ tooltip="Trim selected segment arc or circle on intersection points nearest to the graphic selection"
+ icon="icons/Sketch/trim.png">
+ <sketch_feature_point_selector
+ id="BaseObject"
+ label="Split feature"
+ tooltip="Select feature for split"
+ shape_types="edge"
+ use_external="false"
+ use_graphic_intersection="true">
+ <!--<validator id="SketchPlugin_SplitValidator" parameters="use_graphic_intersection"/> -->
+ </sketch_feature_point_selector>
+ <validator id="PartSet_SplitSelection"/>
+ </feature>
</group>
<group id="Projection">
</feature>
<!-- SketchConstraintCollinear -->
- <!--
<feature id="SketchConstraintCollinear" title="Collinear" tooltip="Create constraint defining collinearity of two lines" icon="icons/Sketch/collinear.png">
<sketch_shape_selector id="ConstraintEntityA"
label="First line" tooltip="Select a line" shape_types="edge">
</sketch_shape_selector>
<validator id="PartSet_CollinearSelection"/>
</feature>
- -->
</group>
{
Handle(AIS_InteractiveContext) aContext = AISContext();
if (!aContext.IsNull()) {
- aContext->UnhilightCurrents(false);
+ aContext->UnhilightSelected(false);//UnhilightCurrents(false);
aContext->ClearSelected(theUpdateViewer);
#ifdef VINSPECTOR
if (getCallBack()) getCallBack()->ClearSelected();
