myFeatureId = std::string(); // Feature unique id
myIsObligatory = true;
myIsConcealment = false;
- myIsGeometricalSelection = false;
}
Config_AttributeMessage::~Config_AttributeMessage()
{
myIsMainArgument = isMainArg;
}
-
-bool Config_AttributeMessage::isGeometricalSelection() const
-{
- return myIsGeometricalSelection;
-}
-
-void Config_AttributeMessage::setGeometricalSelection(bool isGeometricalSelection)
-{
- myIsGeometricalSelection = isGeometricalSelection;
-}
bool myIsObligatory; ///< Required to be set by user, else it's feature is invalid.
bool myIsConcealment; ///< If true, conceals features used as input
bool myIsMainArgument; ///< Mark attribute as a main argument of the feature
- bool myIsGeometricalSelection; ///< If true selects geometry instead of shape;
///< a list of pairs, if the attribute is placed inside paged containers: (case, switch)
std::list<std::pair<std::string, std::string> > myCases;
CONFIG_EXPORT bool isConcealment() const;
/// Returns true if attribute is a main argument of the feature
CONFIG_EXPORT bool isMainArgument() const;
- /// Returns true if attribute selects geometry instead of shape;
- CONFIG_EXPORT bool isGeometricalSelection() const;
/// Returns container of ids of pair of a case and switches
CONFIG_EXPORT const std::list<std::pair<std::string, std::string> >& getCases() const;
/// Sets ids of pair of a case and switches
CONFIG_EXPORT void setObligatory(bool isObligatory);
/// Set a state that the attribute is a main argument of the feature
CONFIG_EXPORT void setMainArgument(bool isMainArg);
- /// Set attribute's geometrical selection state
- CONFIG_EXPORT void setGeometricalSelection(bool isGeometricalSelection);
};
#endif // ATTRIBUTE_MESSAGE_H
aMessage->setConcealment(isConcealment);
bool isMainArg = isConcealment && getBooleanAttribute(theNode, ATTR_MAIN_ARG, false);
aMessage->setMainArgument(isMainArg);
- aMessage->setGeometricalSelection(getBooleanAttribute(theNode,
- ATTR_GEOMETRICAL_SELECTION,
- false));
std::list<std::pair<std::string, std::string> > aCases;
xmlNodePtr aCaseNode = hasParentRecursive(theNode,
const static char* ATTR_GREED = "greed";
const static char* ATTR_MODIFIED_IN_EDIT = "modified_in_edit";
const static char* ATTR_MAIN_ARG = "main_argument";
-const static char* ATTR_GEOMETRICAL_SELECTION = "geometrical_selection";
-
// WDG_INFO properties
const static char* INFO_WDG_TEXT = FEATURE_TEXT;
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
#include <GeomAPI_Pln.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Vertex.h>
#include <GeomAlgoAPI_EdgeBuilder.h>
#include <GeomAlgoAPI_PointBuilder.h>
void ConstructionPlugin_Axis::createAxisByCylindricalFace()
{
- std::shared_ptr<GeomAPI_Shape> aSelection = data()->selection(CYLINDRICAL_FACE())->value();
- // update arguments due to the selection value
-
- if (!aSelection.get() || aSelection->isNull()) {
- return;
- }
-
- if (aSelection->isCompound()) {
- GeomAPI_ShapeIterator anIt(aSelection);
- aSelection = anIt.current();
- }
-
- if (aSelection->isFace()) {
- std::shared_ptr<GeomAPI_Edge> anEdge = GeomAlgoAPI_EdgeBuilder::cylinderAxis(aSelection);
-
- ResultConstructionPtr aConstr = document()->createConstruction(data());
- aConstr->setInfinite(true);
- aConstr->setShape(anEdge);
- setResult(aConstr);
- }
+ std::shared_ptr<GeomAPI_Shape> aSelection = data()->selection(CYLINDRICAL_FACE())->value();
+ // update arguments due to the selection value
+ if (aSelection && !aSelection->isNull() && aSelection->isFace()) {
+ std::shared_ptr<GeomAPI_Edge> anEdge = GeomAlgoAPI_EdgeBuilder::cylinderAxis(aSelection);
+
+ ResultConstructionPtr aConstr = document()->createConstruction(data());
+ aConstr->setInfinite(true);
+ aConstr->setShape(anEdge);
+ setResult(aConstr);
+ }
}
void ConstructionPlugin_Axis::createAxisByDimensions()
if(!aLineShape.get()) {
aLineShape = anEdgeSelection->context()->shape();
}
- GeomEdgePtr anEdge;
- if (aLineShape->isEdge()) {
- anEdge = aLineShape->edge();
- }
- else if (aLineShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aLineShape);
- anEdge = anIt.current()->edge();
- }
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aLineShape));
ResultConstructionPtr aConstr = document()->createConstruction(data());
aConstr->setInfinite(true);
if(!aFaceShape.get()) {
aFaceShape = aFaceSelection->context()->shape();
}
- GeomFacePtr aFace;
- if (aFaceShape->isFace()) {
- aFace = aFaceShape->face();
- }
- else if (aFaceShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFaceShape);
- aFace = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aFaceShape));
std::shared_ptr<GeomAPI_Pln> aPln = aFace->getPlane();
// Get point.
if(!aFaceShape1.get()) {
aFaceShape1 = aFaceSelection1->context()->shape();
}
- std::shared_ptr<GeomAPI_Face> aFace1;
- if (aFaceShape1->isFace()) {
- aFace1 = aFaceShape1->face();
- }
- else if (aFaceShape1->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFaceShape1);
- aFace1 = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Face> aFace1(new GeomAPI_Face(aFaceShape1));
std::shared_ptr<GeomAPI_Pln> aPln1 = aFace1->getPlane();
std::string useOffset1 = string(USE_OFFSET1())->value();
if(!aFaceShape2.get()) {
aFaceShape2 = aFaceSelection2->context()->shape();
}
- std::shared_ptr<GeomAPI_Face> aFace2;
- if (aFaceShape2->isFace()) {
- aFace2 = aFaceShape2->face();
- }
- else if (aFaceShape2->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFaceShape2);
- aFace2 = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Face> aFace2(new GeomAPI_Face(aFaceShape2));
std::shared_ptr<GeomAPI_Pln> aPln2 = aFace2->getPlane();
std::string useOffset2 = string(USE_OFFSET2())->value();
#include <GeomAPI_Pln.h>
#include <GeomAPI_Pnt.h>
#include <GeomAPI_Pnt2d.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Vertex.h>
#include <GeomAPI_XYZ.h>
if(!aLineShape.get()) {
aLineShape = anEdgeSelection->context()->shape();
}
- std::shared_ptr<GeomAPI_Edge> anEdge;
- if (aLineShape->isEdge()) {
- anEdge = aLineShape->edge();
- }
- else if (aLineShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aLineShape);
- anEdge = anIt.current()->edge();
- }
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aLineShape));
// Get point.
AttributeSelectionPtr aPointSelection = selection(POINT());
return aPlane;
}
- std::shared_ptr<GeomAPI_Face> aFace;
- if (aShape->isFace()) {
- aFace = aShape->face();
- }
- else if (aShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aShape);
- aFace = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aShape));
std::shared_ptr<GeomAPI_Pln> aPln = aFace->getPlane();
std::shared_ptr<GeomAPI_Pnt> aOrig = aPln->location();
if(!aFaceShape.get()) {
aFaceShape = aFaceSelection->context()->shape();
}
- std::shared_ptr<GeomAPI_Face> aFace;
- if (aFaceShape->isFace()) {
- aFace = aFaceShape->face();
- }
- else if (aFaceShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFaceShape);
- aFace = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aFaceShape));
// Get point.
AttributeSelectionPtr aPointSelection = selection(COINCIDENT_POINT());
if(!aFaceShape.get()) {
aFaceShape = aFaceSelection->context()->shape();
}
- std::shared_ptr<GeomAPI_Face> aFace;
- if (aFaceShape->isFace()) {
- aFace = aFaceShape->face();
- }
- else if (aFaceShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFaceShape);
- aFace = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aFaceShape));
aFace = makeRectangularFace(aFace, aFace->getPlane());
// Get axis.
if(!anAxisShape.get()) {
anAxisShape = anAxisSelection->context()->shape();
}
- std::shared_ptr<GeomAPI_Edge> anEdge;
- if (anAxisShape->isEdge()) {
- anEdge = anAxisShape->edge();
- }
- else if (anAxisShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(anAxisShape);
- anEdge = anIt.current()->edge();
- }
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(anAxisShape));
std::shared_ptr<GeomAPI_Ax1> anAxis =
std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(anEdge->line()->location(),
if(!aFaceShape1.get()) {
aFaceShape1 = aFaceSelection1->context()->shape();
}
- std::shared_ptr<GeomAPI_Face> aFace1;
- if (aFaceShape1->isFace()) {
- aFace1 = aFaceShape1->face();
- }
- else if (aFaceShape1->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFaceShape1);
- aFace1 = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Face> aFace1(new GeomAPI_Face(aFaceShape1));
std::shared_ptr<GeomAPI_Pln> aPln1 = aFace1->getPlane();
// Get plane 2.
if(!aFaceShape2.get()) {
aFaceShape2 = aFaceSelection2->context()->shape();
}
- std::shared_ptr<GeomAPI_Face> aFace2;
- if (aFaceShape2->isFace()) {
- aFace2 = aFaceShape2->face();
- }
- else if (aFaceShape2->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFaceShape2);
- aFace2 = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Face> aFace2(new GeomAPI_Face(aFaceShape2));
std::shared_ptr<GeomAPI_Pln> aPln2 = aFace2->getPlane();
std::shared_ptr<GeomAPI_Pnt> anOrig1 = aPln1->location();
#include <GeomAPI_Pnt.h>
#include <GeomAPI_Vertex.h>
#include <GeomAPI_Pln.h>
-#include <GeomAPI_ShapeIterator.h>
//==================================================================================================
ConstructionPlugin_Point::ConstructionPlugin_Point()
if(!aLineShape.get()) {
aLineShape = aLineSelection->context()->shape();
}
- GeomEdgePtr anEdge;
- if (aLineShape->isEdge()) {
- anEdge = aLineShape->edge();
- }
- else if (aLineShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aLineShape);
- anEdge = anIt.current()->edge();
- }
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aLineShape));
// Get plane.
AttributeSelectionPtr aPlaneSelection= selection(INTERSECTION_PLANE());
if(!aPlaneShape.get()) {
aPlaneShape = aPlaneSelection->context()->shape();
}
- GeomFacePtr aFace;
- if (aPlaneShape->isFace()) {
- aFace = aPlaneShape->face();
- }
- else if (aPlaneShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aPlaneShape);
- aFace = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aPlaneShape));
if (!string(USE_OFFSET())->value().empty()) {
double anOffset = real(OFFSET())->value();
#include <GeomAPI_Pln.h>
#include <GeomAPI_Vertex.h>
#include <GeomAPI_Pnt.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAlgoAPI_ShapeTools.h>
#include <ModelAPI_AttributeSelection.h>
#include <Events_InfoMessage.h>
static std::shared_ptr<GeomAPI_Edge> getEdge(const GeomShapePtr theShape);
-static std::shared_ptr<GeomAPI_Face> getFace(const GeomShapePtr theShape);
static std::shared_ptr<GeomAPI_Lin> getLin(const GeomShapePtr theShape);
static std::shared_ptr<GeomAPI_Pln> getPln(const GeomShapePtr theShape);
static std::shared_ptr<GeomAPI_Pnt> getPnt(const GeomShapePtr theShape);
AttributeSelectionPtr anAttribute2 = aFeature->selection(theArguments.front());
std::shared_ptr<GeomAPI_Edge> anEdge;
- std::shared_ptr<GeomAPI_Face> aFace;
+ std::shared_ptr<GeomAPI_Pln> aPln;
GeomShapePtr aShape1 = anAttribute1->value();
ResultPtr aContext1 = anAttribute1->context();
bool isPlaneFirst = false;
anEdge = getEdge(aShape1);
-
- aFace = getFace(aShape2);
- if(!anEdge.get() || !aFace.get()) {
+ aPln = getPln(aShape2);
+ if(!anEdge.get() || !aPln.get()) {
anEdge = getEdge(aShape2);
- aFace = getFace(aShape1);
+ aPln = getPln(aShape1);
isPlaneFirst = true;
}
- if(!anEdge.get() || !aFace.get()) {
+ if(!anEdge.get() || !aPln.get()) {
theError = "Wrong shape types selected.";
return false;
}
- if(GeomAlgoAPI_ShapeTools::isParallel(anEdge, aFace)) {
+ std::shared_ptr<GeomAPI_Face> aPlaneFace(new GeomAPI_Face(isPlaneFirst ? aShape1 : aShape2));
+ if(GeomAlgoAPI_ShapeTools::isParallel(anEdge, aPlaneFace)) {
theError = "Plane and edge are parallel.";
return false;
}
std::shared_ptr<GeomAPI_Edge> getEdge(const GeomShapePtr theShape)
{
- GeomEdgePtr anEdge;
-
- if(theShape->isEdge()) {
- anEdge = theShape->edge();
+ if(!theShape->isEdge()) {
+ return std::shared_ptr<GeomAPI_Edge>();
}
- else if (theShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(theShape);
- anEdge = anIt.current()->edge();
- }
-
- return anEdge;
-}
-GeomFacePtr getFace(const GeomShapePtr theShape)
-{
- GeomFacePtr aFace;
-
- if (theShape->isFace()) {
- aFace = theShape->face();
- }
- else if (theShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(theShape);
- aFace = anIt.current()->face();
- }
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(theShape));
- return aFace;
+ return anEdge;
}
std::shared_ptr<GeomAPI_Lin> getLin(const GeomShapePtr theShape)
{
std::shared_ptr<GeomAPI_Lin> aLin;
- GeomEdgePtr anEdge;
-
- if (theShape->isEdge()) {
- anEdge = theShape->edge();
- }
- else if (theShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(theShape);
- anEdge = anIt.current()->edge();
- }
- else {
+ if(!theShape->isEdge()) {
return aLin;
}
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(theShape));
+
if(!anEdge->isLine()) {
return aLin;
}
{
std::shared_ptr<GeomAPI_Pln> aPln;
- GeomFacePtr aFace;
-
- if(theShape->isFace()) {
- aFace = theShape->face();
- }
- else if (theShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(theShape);
- aFace = anIt.current()->face();
- }
- else {
+ if(!theShape->isFace()) {
return aPln;
}
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(theShape));
+
if(!aFace->isPlanar()) {
return aPln;
}
label="Line"
tooltip="Select line."
icon="icons/Construction/edge.png"
- shape_types="edge"
- geometrical_selection="true">
+ shape_types="edge">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
</box>
label="Main object"
icon="icons/Construction/circle.png"
tooltip="Select a cylindrical object"
- shape_types="face"
- geometrical_selection="true">
+ shape_types="face">
<validator id="GeomValidators_Face" parameters="cylinder"/>
</shape_selector>
</box>
label="Plane"
tooltip="Select a planar face."
icon="icons/Construction/face.png"
- shape_types="face"
- geometrical_selection="true">
+ shape_types="face">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
<shape_selector id="point"
label="1st plane"
tooltip="Select a planar face."
icon="icons/Construction/face.png"
- shape_types="face"
- geometrical_selection="true">
+ shape_types="face">
<validator id="GeomValidators_Face" parameters="plane"/>
<validator id="ConstructionPlugin_ValidatorAxisTwoNotParallelPlanes" parameters="plane2"/>
</shape_selector>
label="2nd plane"
tooltip="Select a planar face."
icon="icons/Construction/face.png"
- shape_types="face"
- geometrical_selection="true">
+ shape_types="face">
<validator id="GeomValidators_Face" parameters="plane"/>
<validator id="ConstructionPlugin_ValidatorAxisTwoNotParallelPlanes" parameters="plane1"/>
</shape_selector>
label="Line"
tooltip="Select line."
icon="icons/Construction/edge.png"
- shape_types="edge"
- geometrical_selection="true">
+ shape_types="edge">
<validator id="GeomValidators_ShapeType" parameters="line"/>
<validator id="ConstructionPlugin_ValidatorPlaneLinePoint" parameters="point,perpendicular"/>
</shape_selector>
label="Plane"
tooltip="Select a planar face."
icon="icons/Construction/face.png"
- shape_types="face"
- geometrical_selection="true">
+ shape_types="face">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
<toolbox id="by_other_plane_option">
label="Axis"
tooltip="Select line for axis."
icon="icons/Construction/axis.png"
- shape_types="edge"
- geometrical_selection="true">
+ shape_types="edge">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
<doublevalue id="angle"
label="1st plane"
tooltip="Select a planar face."
icon="icons/Construction/face.png"
- shape_types="face"
- geometrical_selection="true">
+ shape_types="face">
<validator id="GeomValidators_Face" parameters="plane"/>
<validator id="ConstructionPlugin_ValidatorPlaneTwoParallelPlanes" parameters="plane2"/>
</shape_selector>
label="2nd plane"
tooltip="Select a planar face."
icon="icons/Construction/face.png"
- shape_types="face"
- geometrical_selection="true">
+ shape_types="face">
<validator id="GeomValidators_Face" parameters="plane"/>
<validator id="ConstructionPlugin_ValidatorPlaneTwoParallelPlanes" parameters="plane1"/>
</shape_selector>
label="Line"
tooltip="Line for intersection."
icon="icons/Construction/edge.png"
- shape_types="edge"
- geometrical_selection="true">
+ shape_types="edge">
<validator id="ConstructionPlugin_ValidatorPointEdgeAndPlaneNotParallel"
parameters="intersection_plane"/>
</shape_selector>
label="Plane"
tooltip="Plane for intersection."
icon="icons/Construction/face.png"
- shape_types="face"
- geometrical_selection="true">
+ shape_types="face">
<validator id="GeomValidators_Face" parameters="plane"/>
<validator id="ConstructionPlugin_ValidatorPointEdgeAndPlaneNotParallel"
parameters="intersection_line"/>
#include <GeomAPI_Dir.h>
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
-#include <GeomAPI_ShapeIterator.h>
//=================================================================================================
FeaturesPlugin_Extrusion::FeaturesPlugin_Extrusion()
getBaseShapes(theBaseShapes);
//Getting direction.
- static const std::string aSelectionError = "Error: The direction shape selection is bad.";
+ std::shared_ptr<GeomAPI_Dir> aDir;
+ std::shared_ptr<GeomAPI_Edge> anEdge;
AttributeSelectionPtr aSelection = selection(DIRECTION_OBJECT_ID());
- GeomShapePtr aShape = aSelection->value();
- if (!aShape.get()) {
- if (aSelection->context().get()) {
- aShape = aSelection->context()->shape();
- }
- }
-
- GeomEdgePtr anEdge;
- if (aShape.get()) {
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
- }
+ if(aSelection.get() && aSelection->value().get() && aSelection->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aSelection->value()));
+ } else if(aSelection->context().get() &&
+ aSelection->context()->shape().get() &&
+ aSelection->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aSelection->context()->shape()));
}
-
- std::shared_ptr<GeomAPI_Dir> aDir;
if(anEdge.get()) {
if(anEdge->isLine()) {
aDir = anEdge->line()->direction();
if(!aToShape.get() && aSelection->context().get()) {
aToShape = aSelection->context()->shape();
}
- if (aToShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aToShape);
- aToShape = anIt.current();
- }
}
aSelection = selection(FROM_OBJECT_ID());
if(aSelection.get()) {
if(!aFromShape.get() && aSelection->context().get()) {
aFromShape = aSelection->context()->shape();
}
- if (aFromShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFromShape);
- aFromShape = anIt.current();
- }
}
}
#include <GeomAPI_Ax1.h>
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Trsf.h>
#include <ModelAPI_AttributeDouble.h>
}
//Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
- AttributeSelectionPtr anObjRef = selection(AXIS_ANGULAR_ID());
- GeomShapePtr aShape = anObjRef->value();
- if (!aShape.get()) {
- if (anObjRef->context().get()) {
- aShape = anObjRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
- }
-
- GeomEdgePtr anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
- }
- else
- {
- setError(aSelectionError);
- return;
+ std::shared_ptr<GeomAPI_Ax1> anAxis;
+ std::shared_ptr<GeomAPI_Edge> anEdge;
+ std::shared_ptr<ModelAPI_AttributeSelection> anObjRef =
+ selection(FeaturesPlugin_MultiRotation::AXIS_ANGULAR_ID());
+ if(anObjRef && anObjRef->value() && anObjRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->value()));
+ } else if (anObjRef && !anObjRef->value() && anObjRef->context() &&
+ anObjRef->context()->shape() && anObjRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->context()->shape()));
}
-
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
+ if(anEdge) {
+ anAxis = std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(anEdge->line()->location(),
+ anEdge->line()->direction()));
}
- std::shared_ptr<GeomAPI_Ax1> anAxis(new GeomAPI_Ax1(anEdge->line()->location(),
- anEdge->line()->direction()));
-
// Getting number of copies.
int nbCopies =
integer(FeaturesPlugin_MultiRotation::NB_COPIES_ANGULAR_ID())->value();
#include <GeomAPI_Ax1.h>
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Trsf.h>
#include <ModelAPI_AttributeDouble.h>
}
//Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
- AttributeSelectionPtr anObjRef = selection(AXIS_FIRST_DIR_ID());
- GeomShapePtr aShape = anObjRef->value();
- if (!aShape.get()) {
- if (anObjRef->context().get()) {
- aShape = anObjRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
- }
-
- GeomEdgePtr anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
+ std::shared_ptr<GeomAPI_Ax1> anAxis;
+ std::shared_ptr<GeomAPI_Edge> anEdge;
+ std::shared_ptr<ModelAPI_AttributeSelection> anObjRef =
+ selection(FeaturesPlugin_MultiTranslation::AXIS_FIRST_DIR_ID());
+ if(anObjRef && anObjRef->value() && anObjRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->value()));
+ } else if (anObjRef && !anObjRef->value() && anObjRef->context() &&
+ anObjRef->context()->shape() && anObjRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->context()->shape()));
}
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
- }
- else
- {
- setError(aSelectionError);
- return;
- }
-
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
+ if(anEdge) {
+ anAxis = std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(anEdge->line()->location(),
+ anEdge->line()->direction()));
}
- std::shared_ptr<GeomAPI_Ax1> anAxis (new GeomAPI_Ax1(anEdge->line()->location(),
- anEdge->line()->direction()));
-
// Getting step.
double aStep = real(FeaturesPlugin_MultiTranslation::STEP_FIRST_DIR_ID())->value();
}
//Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
- AttributeSelectionPtr anObjRef = selection(AXIS_FIRST_DIR_ID());
- GeomShapePtr aShape = anObjRef->value();
- if (!aShape.get()) {
- if (anObjRef->context().get()) {
- aShape = anObjRef->context()->shape();
- }
+ std::shared_ptr<GeomAPI_Ax1> aFirstAxis;
+ std::shared_ptr<GeomAPI_Edge> anEdge;
+ std::shared_ptr<ModelAPI_AttributeSelection> anObjRef =
+ selection(FeaturesPlugin_MultiTranslation::AXIS_FIRST_DIR_ID());
+ if(anObjRef && anObjRef->value() && anObjRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->value()));
+ } else if (anObjRef && !anObjRef->value() && anObjRef->context() &&
+ anObjRef->context()->shape() && anObjRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->context()->shape()));
}
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
+ if(anEdge) {
+ aFirstAxis = std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(anEdge->line()->location(),
+ anEdge->line()->direction()));
}
-
- GeomEdgePtr anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
+ std::shared_ptr<GeomAPI_Ax1> aSecondAxis;
+ anObjRef = selection(FeaturesPlugin_MultiTranslation::AXIS_SECOND_DIR_ID());
+ if(anObjRef && anObjRef->value() && anObjRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->value()));
+ } else if (anObjRef && !anObjRef->value() && anObjRef->context() &&
+ anObjRef->context()->shape() && anObjRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->context()->shape()));
}
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
+ if(anEdge) {
+ aSecondAxis = std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(anEdge->line()->location(),
+ anEdge->line()->direction()));
}
- else
- {
- setError(aSelectionError);
- return;
- }
-
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
- }
-
- std::shared_ptr<GeomAPI_Ax1> aFirstAxis(new GeomAPI_Ax1(anEdge->line()->location(),
- anEdge->line()->direction()));
-
- //Getting axis.
- anObjRef = selection(AXIS_SECOND_DIR_ID());
- aShape = anObjRef->value();
- if (!aShape.get()) {
- if (anObjRef->context().get()) {
- aShape = anObjRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
- }
-
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
- }
- else
- {
- setError(aSelectionError);
- return;
- }
-
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
- }
-
- std::shared_ptr<GeomAPI_Ax1> aSecondAxis(new GeomAPI_Ax1(anEdge->line()->location(),
- anEdge->line()->direction()));
// Getting step.
double aFirstStep = real(FeaturesPlugin_MultiTranslation::STEP_FIRST_DIR_ID())->value();
#include <GeomAPI_Edge.h>
#include <GeomAPI_Face.h>
#include <GeomAPI_Pln.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAlgoAPI_Placement.h>
#include <GeomAlgoAPI_Transform.h>
// Verify planarity of faces and linearity of edges
std::shared_ptr<GeomAPI_Shape> aShapes[2] = {aStartShape, anEndShape};
for (int i = 0; i < 2; i++) {
- if (!isShapeValid(aShapes[i])) {
- return;
+ if (aShapes[i]->isFace()) {
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aShapes[i]));
+ if (!aFace->isPlanar()) {
+ static const std::string aPlanarityError = "Error: One of selected faces is not planar.";
+ setError(aPlanarityError);
+ return;
+ }
+ }
+ else if (aShapes[i]->isEdge()) {
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aShapes[i]));
+ if (!anEdge->isLine()) {
+ static const std::string aLinearityError = "Error: One of selected endges is not linear.";
+ setError(aLinearityError);
+ return;
+ }
}
}
removeResults(aResultIndex);
}
-//==================================================================================================
-bool FeaturesPlugin_Placement::isShapeValid(GeomShapePtr theShape)
-{
- if (theShape->isCompound()) {
- GeomAPI_Shape::ShapeType aShapeType = GeomAPI_Shape::SHAPE;
- for (GeomAPI_ShapeIterator anIt(theShape); anIt.more(); anIt.next()) {
- GeomShapePtr aCurrentShape = anIt.current();
- if (aShapeType == GeomAPI_Shape::SHAPE) {
- aShapeType = aCurrentShape->shapeType();
- }
- else if (aShapeType != aCurrentShape->shapeType()) {
- static const std::string aLinearityError =
- "Error: Selected compound contains shapes with different types.";
- setError(aLinearityError);
- return false;
- }
-
- if (!isShapeValid(aCurrentShape)) {
- return false;
- }
- }
- }
- else if (theShape->isFace()) {
- std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(theShape));
- if (!aFace->isPlanar()) {
- static const std::string aPlanarityError = "Error: One of selected faces is not planar.";
- setError(aPlanarityError);
- return false;
- }
- }
- else if (theShape->isEdge()) {
- std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(theShape));
- if (!anEdge->isLine()) {
- static const std::string aLinearityError = "Error: One of selected edges is not linear.";
- setError(aLinearityError);
- return false;
- }
- }
-
- return true;
-}
-
//============================================================================
void FeaturesPlugin_Placement::loadNamingDS(GeomAlgoAPI_Transform& theTransformAlgo,
std::shared_ptr<ModelAPI_ResultBody> theResultBody,
/// Use plugin manager for features creation
FeaturesPlugin_Placement();
private:
- /// Checks validity of passed shape.
- bool isShapeValid(GeomShapePtr theShape);
-
/// Load Naming data structure of the feature to the document
void loadNamingDS(GeomAlgoAPI_Transform& theTransformAlgo,
std::shared_ptr<ModelAPI_ResultBody> theResultBody,
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
-#include <GeomAPI_ShapeIterator.h>
//=================================================================================================
FeaturesPlugin_Revolution::FeaturesPlugin_Revolution()
// Getting base shapes.
getBaseShapes(theBaseShapes);
- // Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
+ //Getting axis.
+ std::shared_ptr<GeomAPI_Ax1> anAxis;
+ std::shared_ptr<GeomAPI_Edge> anEdge;
AttributeSelectionPtr aSelection = selection(AXIS_OBJECT_ID());
- GeomShapePtr aShape = aSelection->value();
- if (!aShape.get()) {
- if (aSelection->context().get()) {
- aShape = aSelection->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return false;
- }
-
- GeomEdgePtr anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
+ if(aSelection.get() && aSelection->value().get() && aSelection->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aSelection->value()));
+ } else if(aSelection->context().get() &&
+ aSelection->context()->shape().get() &&
+ aSelection->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aSelection->context()->shape()));
}
- else
- {
- setError(aSelectionError);
- return false;
- }
-
- std::shared_ptr<GeomAPI_Ax1> anAxis;
if(anEdge.get()) {
if(anEdge->isLine()) {
anAxis = std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(anEdge->line()->location(),
if(!aToShape.get() && aSelection->context().get()) {
aToShape = aSelection->context()->shape();
}
- if (aToShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aToShape);
- aToShape = anIt.current();
- }
}
aSelection = selection(FROM_OBJECT_ID());
if(aSelection.get()) {
if(!aFromShape.get() && aSelection->context().get()) {
aFromShape = aSelection->context()->shape();
}
- if (aFromShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFromShape);
- aFromShape = anIt.current();
- }
}
}
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Trsf.h>
#include <FeaturesPlugin_Tools.h>
}
//Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
- AttributeSelectionPtr anObjRef = selection(AXIS_OBJECT_ID());
- GeomShapePtr aShape = anObjRef->value();
- if (!aShape.get()) {
- if (anObjRef->context().get()) {
- aShape = anObjRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
+ std::shared_ptr<GeomAPI_Ax1> anAxis;
+ std::shared_ptr<GeomAPI_Edge> anEdge;
+ std::shared_ptr<ModelAPI_AttributeSelection> anObjRef =
+ selection(FeaturesPlugin_Rotation::AXIS_OBJECT_ID());
+ if(anObjRef && anObjRef->value() && anObjRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->value()));
+ } else if (anObjRef && !anObjRef->value() && anObjRef->context() &&
+ anObjRef->context()->shape() && anObjRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->context()->shape()));
}
-
- GeomEdgePtr anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
+ if(anEdge) {
+ anAxis = std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(anEdge->line()->location(),
+ anEdge->line()->direction()));
}
- else
- {
- setError(aSelectionError);
- return;
- }
-
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
- }
-
- std::shared_ptr<GeomAPI_Ax1> anAxis (new GeomAPI_Ax1(anEdge->line()->location(),
- anEdge->line()->direction()));
// Getting angle.
double anAngle = real(FeaturesPlugin_Rotation::ANGLE_ID())->value();
#include <GeomAPI_Face.h>
#include <GeomAPI_Lin.h>
#include <GeomAPI_Pln.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Trsf.h>
#include <ModelAPI_AttributeBoolean.h>
return;
//Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
- AttributeSelectionPtr anObjRef = selection(AXIS_OBJECT_ID());
- GeomShapePtr aShape = anObjRef->value();
- if (!aShape.get()) {
- if (anObjRef->context().get()) {
- aShape = anObjRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
- }
-
- GeomEdgePtr anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
- }
- else
- {
- setError(aSelectionError);
- return;
+ std::shared_ptr<GeomAPI_Ax1> anAxis;
+ std::shared_ptr<GeomAPI_Edge> anEdge;
+ std::shared_ptr<ModelAPI_AttributeSelection> anObjRef =
+ selection(FeaturesPlugin_Symmetry::AXIS_OBJECT_ID());
+ if(anObjRef && anObjRef->value() && anObjRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->value()));
+ } else if (anObjRef && !anObjRef->value() && anObjRef->context() &&
+ anObjRef->context()->shape() && anObjRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->context()->shape()));
}
-
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
+ if(anEdge) {
+ anAxis = std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(anEdge->line()->location(),
+ anEdge->line()->direction()));
}
- std::shared_ptr<GeomAPI_Ax1> anAxis (new GeomAPI_Ax1(anEdge->line()->location(),
- anEdge->line()->direction()));
-
-
// Moving each object.
int aResultIndex = 0;
std::list<ResultPtr>::iterator aContext = aContextes.begin();
if (!collectSourceObjects(anObjects, aContextes))
return;
- //Getting plane.
- static const std::string aSelectionError = "Error: The plane shape selection is bad.";
- AttributeSelectionPtr anObjRef = selection(PLANE_OBJECT_ID());
- GeomShapePtr aShape = anObjRef->value();
- if (!aShape.get()) {
- if (anObjRef->context().get()) {
- aShape = anObjRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
- }
-
- GeomFacePtr aFace;
- if (aShape->isFace())
- {
- aFace = aShape->face();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- aFace = anIt.current()->face();
+ //Getting axis.
+ std::shared_ptr<GeomAPI_Ax2> aPlane;
+ std::shared_ptr<GeomAPI_Pln> aPln;
+ std::shared_ptr<ModelAPI_AttributeSelection> anObjRef =
+ selection(FeaturesPlugin_Symmetry::PLANE_OBJECT_ID());
+ if (anObjRef && anObjRef->value() && anObjRef->value()->isFace()) {
+ aPln = std::shared_ptr<GeomAPI_Face>(new GeomAPI_Face(anObjRef->value()))->getPlane();
}
- else
- {
- setError(aSelectionError);
- return;
+ else if (anObjRef && !anObjRef->value() && anObjRef->context() &&
+ anObjRef->context()->shape() && anObjRef->context()->shape()->isFace()) {
+ aPln =
+ std::shared_ptr<GeomAPI_Face>(new GeomAPI_Face(anObjRef->context()->shape()))->getPlane();
}
-
- if (!aFace.get())
- {
- setError(aSelectionError);
- return;
+ if (aPln) {
+ aPlane = std::shared_ptr<GeomAPI_Ax2>(new GeomAPI_Ax2(aPln->location(),
+ aPln->direction()));
}
- std::shared_ptr<GeomAPI_Ax2> aPlane(new GeomAPI_Ax2(aFace->getPlane()->location(),
- aFace->getPlane()->direction()));
-
-
// Moving each object.
int aResultIndex = 0;
std::list<ResultPtr>::iterator aContext = aContextes.begin();
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Trsf.h>
#include <GeomAlgoAPI_PointBuilder.h>
}
//Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
- AttributeSelectionPtr anObjRef = selection(AXIS_OBJECT_ID());
- GeomShapePtr aShape = anObjRef->value();
- if (!aShape.get()) {
- if (anObjRef->context().get()) {
- aShape = anObjRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
- }
-
- GeomEdgePtr anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
+ std::shared_ptr<GeomAPI_Ax1> anAxis;
+ std::shared_ptr<GeomAPI_Edge> anEdge;
+ std::shared_ptr<ModelAPI_AttributeSelection> anObjRef =
+ selection(FeaturesPlugin_Translation::AXIS_OBJECT_ID());
+ if(anObjRef && anObjRef->value() && anObjRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->value()));
+ } else if (anObjRef && !anObjRef->value() && anObjRef->context() &&
+ anObjRef->context()->shape() && anObjRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anObjRef->context()->shape()));
}
- else
- {
- setError(aSelectionError);
- return;
- }
-
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
+ if(anEdge) {
+ anAxis = std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(anEdge->line()->location(),
+ anEdge->line()->direction()));
}
- std::shared_ptr<GeomAPI_Ax1> anAxis(new GeomAPI_Ax1(anEdge->line()->location(),
- anEdge->line()->direction()));
-
-
// Getting distance.
double aDistance = real(FeaturesPlugin_Translation::DISTANCE_ID())->value();
if(aContext.get()) {
aDirShape = aContext->shape();
}
-
- if (aDirShape.get() && aDirShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aDirShape);
- aDirShape = anIt.current();
- }
}
}
label="Direction"
tooltip="Select an edge for direction"
shape_types="edge"
- geometrical_selection="true"
default="<base normal>">
<validator id="GeomValidators_ShapeType" parameters="empty,line"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<base sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<base sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Direction"
tooltip="Select an edge for direction"
shape_types="edge"
- geometrical_selection="true"
default="<base normal>">
<validator id="GeomValidators_ShapeType" parameters="empty,line"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<base sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<base sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Direction"
tooltip="Select an edge for direction"
shape_types="edge"
- geometrical_selection="true"
default="<base normal>">
<validator id="GeomValidators_ShapeType" parameters="empty,line"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<base sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<base sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Axis"
tooltip="Select an edge for the angular direction"
shape_types="edge"
- default=""
- geometrical_selection="true">
+ default="">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
<optionalbox id="use_step_angular" title="Angular step">
label="Axis"
tooltip="Select an edge for the first direction"
shape_types="edge"
- default=""
- geometrical_selection="true">
+ default="">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
<doublevalue id="step_first_dir"
label="Axis"
tooltip="Select an edge for the second direction"
shape_types="edge"
- default=""
- geometrical_selection="true">
+ default="">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
<doublevalue id="step_second_dir"
label="Select an object"
icon="icons/Features/placement_from.png"
tooltip="Select a start face, edge or vertex"
- shape_types="face edge vertex"
- geometrical_selection="true">
+ shape_types="face edge vertex">
<validator id="GeomValidators_BodyShapes"/>
</shape_selector>
<shape_selector id="placement_end_shape"
label="Select an object"
icon="icons/Features/placement_to.png"
tooltip="Select an end face, edge or vertex"
- shape_types="face edge vertex"
- geometrical_selection="true">
+ shape_types="face edge vertex">
<validator id="PartSet_DifferentObjects"/>
<validator id="GeomValidators_BodyShapes"/>
</shape_selector>
label="Axis"
tooltip="Select an edge for axis"
shape_types="edge"
- geometrical_selection="true"
default="">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<base sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<base sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Axis"
tooltip="Select an edge for axis"
shape_types="edge"
- geometrical_selection="true"
default="">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Axis"
tooltip="Select an edge for axis"
shape_types="edge"
- geometrical_selection="true"
default="">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Plane face"
tooltip="Bounding plane (select a planar face)"
shape_types="face"
- geometrical_selection="true"
default="<sketch>">
<validator id="GeomValidators_Face" parameters="plane"/>
</shape_selector>
label="Axis"
tooltip="Select an edge for axis"
shape_types="edge"
- default=""
- geometrical_selection="true">
+ default="">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
<doublevalue id="angle"
label="Axis"
tooltip="Select an axis"
shape_types="edge"
- default=""
- geometrical_selection="true">
+ default="">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
</box>
label="Axis"
tooltip="Select an edge for axis"
shape_types="edge"
- default=""
- geometrical_selection="true">
+ default="">
<validator id="GeomValidators_ShapeType" parameters="line"/>
</shape_selector>
<doublevalue id="distance"
#include "GeomAlgoAPI_Placement.h"
#include <GeomAlgoAPI_DFLoader.h>
-#include <GeomAlgoAPI_ShapeTools.h>
#include <GeomAPI_Dir.h>
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
#include <GeomAPI_Pnt.h>
#include <GeomAPI_Pln.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Vertex.h>
#include <GeomAPI_XYZ.h>
GProp_GProps aProps;
static const double aPropEps = 1.e-4;
- GeomShapePtr aShape;
- bool isCompound = false;
for (int i = 0; i < aNbObjects; i++) {
- aShape = aShapes[i];
- isCompound = false;
- if (aShapes[i]->isCompound()) {
- isCompound = true;
- GeomAPI_ShapeIterator anIt(aShapes[i]);
- aShape = anIt.current();
-
- GeomPointPtr aPnt = GeomAlgoAPI_ShapeTools::centreOfMass(aShapes[i]);
- aSrcDstPoints[i].SetCoord(aPnt->x(), aPnt->y(), aPnt->z());
- }
-
- if (aShape->isFace()) {
- std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aShape));
+ if (aShapes[i]->isFace()) {
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aShapes[i]));
std::shared_ptr<GeomAPI_Pln> aPlane = aFace->getPlane();
std::shared_ptr<GeomAPI_Dir> aDir = aPlane->direction();
aSrcDstNormals[i].SetCoord(aDir->x(), aDir->y(), aDir->z());
- if (!isCompound) {
- BRepGProp::SurfaceProperties(aFace->impl<TopoDS_Face>(), aProps, aPropEps);
- gp_Pnt aLoc = aProps.CentreOfMass();
- aSrcDstPoints[i].SetCoord(aLoc.X(), aLoc.Y(), aLoc.Z());
- }
+ BRepGProp::SurfaceProperties(aFace->impl<TopoDS_Face>(), aProps, aPropEps);
+ gp_Pnt aLoc = aProps.CentreOfMass();
+ aSrcDstPoints[i].SetCoord(aLoc.X(), aLoc.Y(), aLoc.Z());
}
- else if (aShape->isEdge()) {
- std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aShape));
+ else if (aShapes[i]->isEdge()) {
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aShapes[i]));
std::shared_ptr<GeomAPI_Lin> aLine = anEdge->line();
std::shared_ptr<GeomAPI_Dir> aDir = aLine->direction();
+ std::shared_ptr<GeomAPI_Pnt> aFirstPnt = anEdge->firstPoint();
+ std::shared_ptr<GeomAPI_Pnt> aLastPnt = anEdge->lastPoint();
+ std::shared_ptr<GeomAPI_XYZ> aLoc = aFirstPnt->xyz()->added(aLastPnt->xyz())->multiplied(0.5);
+ aSrcDstPoints[i].SetCoord(aLoc->x(), aLoc->y(), aLoc->z());
aSrcDstDirections[i].SetCoord(aDir->x(), aDir->y(), aDir->z());
-
- if (!isCompound) {
- std::shared_ptr<GeomAPI_Pnt> aFirstPnt = anEdge->firstPoint();
- std::shared_ptr<GeomAPI_Pnt> aLastPnt = anEdge->lastPoint();
- std::shared_ptr<GeomAPI_XYZ> aLoc = aFirstPnt->xyz()->added(aLastPnt->xyz())
- ->multiplied(0.5);
- aSrcDstPoints[i].SetCoord(aLoc->x(), aLoc->y(), aLoc->z());
- }
}
- else if (aShape->isVertex()) {
- std::shared_ptr<GeomAPI_Vertex> aVertex(new GeomAPI_Vertex(aShape));
+ else if (aShapes[i]->isVertex()) {
+ std::shared_ptr<GeomAPI_Vertex> aVertex(new GeomAPI_Vertex(aShapes[i]));
std::shared_ptr<GeomAPI_Pnt> aPnt = aVertex->point();
aSrcDstPoints[i].SetCoord(aPnt->x(), aPnt->y(), aPnt->z());
} else // something goes wrong
#include "ModelAPI_AttributeSelection.h"
#include <GeomAPI_Face.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAbs_SurfaceType.hxx>
return GeomAbs_Plane;
}
-bool isValidFace(const GeomShapePtr theShape,
- const GeomAbs_SurfaceType theFaceType,
- Events_InfoMessage& theError)
-{
- GeomFacePtr aGeomFace = theShape->face();
-
- if (!aGeomFace.get()) {
- theError = "The shape is not a face.";
- return false;
- }
-
- bool aValid = true;
-
- switch (theFaceType) {
- case GeomAbs_Plane: {
- aValid = aGeomFace->isPlanar();
- if (!aValid) theError = "The shape is not a plane.";
- break;
- }
- case GeomAbs_Cylinder: {
- aValid = aGeomFace->isCylindrical();
- if (!aValid) theError = "The shape is not a cylinder.";
- break;
- }
- default: {
- aValid = false;
- theError = "The shape is not an available face.";
- break;
- }
- }
-
- return aValid;
-}
-
bool GeomValidators_Face::isValid(const AttributePtr& theAttribute,
const std::list<std::string>& theArguments,
Events_InfoMessage& theError) const
theError = "The shape is not a face.";
}
else {
- GeomAbs_SurfaceType aFaceType = GeomAbs_Plane;
- if (theArguments.size() == 1) aFaceType = faceType(theArguments.front());
- if (aGeomShape->isFace()) {
- isValidFace(aGeomShape, aFaceType, theError);
+ std::shared_ptr<GeomAPI_Face> aGeomFace(new GeomAPI_Face(aGeomShape));
+ if (!aGeomFace.get()) {
+ aValid = false;
+ theError = "The shape is not a face.";
}
- else if (aSelectionAttr->isGeometricalSelection() && aGeomShape->isCompound()) {
- for (GeomAPI_ShapeIterator anIt(aGeomShape); anIt.more(); anIt.next()) {
- if (!isValidFace(anIt.current(), aFaceType, theError)) {
+ else {
+ GeomAbs_SurfaceType aFaceType = GeomAbs_Plane;
+ if (theArguments.size() == 1)
+ aFaceType = faceType(theArguments.front());
+
+ switch (aFaceType) {
+ case GeomAbs_Plane: {
+ aValid = aGeomFace->isPlanar();
+ if (!aValid)
+ theError = "The shape is not a plane.";
+ }
+ break;
+ case GeomAbs_Cylinder:{
+ aValid = aGeomFace->isCylindrical();
+ if (!aValid)
+ theError = "The shape is not a cylinder.";
+ }
+ break;
+ default: {
+ aValid = false;
+ theError = "The shape is not an available face.";
break;
}
}
}
- else {
- aValid = false;
- theError = "The shape is not a face.";
- }
}
}
return aValid;
#include "GeomValidators_Tools.h"
#include <GeomAPI_Curve.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomDataAPI_Point2D.h>
#include <ModelAPI_Result.h>
std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
GeomShapePtr aShape = anAttr->value();
if (aShape.get())
- aValid = isValidShape(aShape, theShapeType, anAttr->isGeometricalSelection(), theError);
+ aValid = isValidShape(aShape, theShapeType, theError);
else {
if (anAttr->context().get())
- aValid = isValidObject(anAttr->context(),
- theShapeType,
- anAttr->isGeometricalSelection(),
- theError);
+ aValid = isValidObject(anAttr->context(), theShapeType, theError);
else
- aValid = isValidObject(anAttr->contextFeature(),
- theShapeType,
- anAttr->isGeometricalSelection(),
- theError);
+ aValid = isValidObject(anAttr->contextFeature(), theShapeType, theError);
}
}
else if (anAttributeType == ModelAPI_AttributeRefAttr::typeId()) {
AttributeRefAttrPtr anAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
if (anAttr->isObject()) {
- aValid = isValidObject(anAttr->object(),
- theShapeType,
- false,
- theError);
+ aValid = isValidObject(anAttr->object(), theShapeType, theError);
}
else if (theShapeType == Vertex) {
AttributePtr aRefAttr = anAttr->attr();
else if (anAttributeType == ModelAPI_AttributeReference::typeId()) {
AttributeReferencePtr anAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeReference>(theAttribute);
- aValid = isValidObject(anAttr->value(), theShapeType, false, theError);
+ aValid = isValidObject(anAttr->value(), theShapeType, theError);
}
else if (anAttributeType == ModelAPI_AttributeSelectionList::typeId()) {
AttributeSelectionListPtr aListAttr =
bool GeomValidators_ShapeType::isValidObject(const ObjectPtr& theObject,
const TypeOfShape theShapeType,
- const bool theIsGeometricalSelection,
Events_InfoMessage& theError) const
{
bool aValid = true;
aValid = false;
theError = "The result is empty";
} else {
- aValid = isValidShape(aResult->shape(), theShapeType, theIsGeometricalSelection, theError);
+ aValid = isValidShape(aResult->shape(), theShapeType, theError);
}
} else {
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
bool GeomValidators_ShapeType::isValidShape(const GeomShapePtr theShape,
const TypeOfShape theShapeType,
- const bool theIsGeometricalSelection,
Events_InfoMessage& theError) const
{
bool aValid = true;
case Edge:
aValid = theShape->isEdge();
break;
- case Line: {
- if (theIsGeometricalSelection && theShape->isCompound()) {
- aValid = true;
- for (GeomAPI_ShapeIterator anIt(theShape); anIt.more(); anIt.next()) {
- if (!anIt.current()->isEdge() || !GeomAPI_Curve(anIt.current()).isLine()) {
- aValid = false;
- break;
- }
- }
- }
- else {
- aValid = theShape->isEdge() && GeomAPI_Curve(theShape).isLine();
- }
+ case Line:
+ aValid = theShape->isEdge() && GeomAPI_Curve(theShape).isLine();
break;
- }
case Circle:
aValid = theShape->isEdge() && GeomAPI_Curve(theShape).isCircle();
break;
/// \param[out] theError error message.
bool isValidObject(const ObjectPtr& theObject,
const TypeOfShape theShapeType,
- const bool theIsGeometricalSelection,
Events_InfoMessage& theError) const;
/// Returns true if the attibute's object type satisfies the argument value
/// \param[out] theError error message.
bool isValidShape(const GeomShapePtr theShape,
const TypeOfShape theShapeType,
- const bool theIsGeometricalSelection,
Events_InfoMessage& theError) const;
};
#include <GeomAPI_Dir.h>
#include <GeomAPI_Face.h>
#include <GeomAPI_Shape.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Pln.h>
#include <GeomAPI_Pnt.h>
if(aToShape.get() == NULL && anAttrSel->context().get() != NULL) {
aToShape = anAttrSel->context()->shape();
}
- if (aToShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aToShape);
- aToShape = anIt.current();
- }
}
anIt++;
if(aFromShape.get() == NULL && anAttrSel->context().get() != NULL) {
aFromShape = anAttrSel->context()->shape();
}
- if (aFromShape->isCompound()) {
- GeomAPI_ShapeIterator anIt(aFromShape);
- aFromShape = anIt.current();
- }
}
anIt++;
#include <Events_InfoMessage.h>
#include <GeomAPI_Edge.h>
#include <GeomAPI_Pnt.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Vertex.h>
#include <GeomAlgoAPI_CompoundBuilder.h>
#include <GeomAlgoAPI_NExplode.h>
{
myRef.setID(theID);
ModelAPI_AttributeSelection::setID(theID);
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
- // TODO: check if parent list have geometrical selection flag.
- myIsGeometricalSelection =
- ModelAPI_Session::get()->validators()->isGeometricalSelection(aFeature->getKind(), id());
}
ResultPtr Model_AttributeSelection::context()
if (aEraseResults) // erase results without flash deleted and redisplay: do it after Select
aFeatureOwner->removeResults(0, false, false);
}
- aSel.Select(aNewSub, aNewContext, myIsGeometricalSelection);
+ aSel.Select(aNewSub, aNewContext);
// face may become divided after the model update, so, new labels may be added to the scope
myScope.Clear();
return "";
}
- if (myIsGeometricalSelection
- && aSubSh.get()
- && aSubSh->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aSubSh);
- aSubSh = anIt.current();
- }
-
Model_SelectionNaming aSelNaming(selectionLabel());
std::string aResult = aSelNaming.namingName(
aCont, aSubSh, theDefaultName, owner()->document() != aCont->document());
CenterType myTmpCenterType;
/// Reference to the partent attribute, if any (to split selection compounds in issue 1799)
Model_AttributeSelectionList* myParent;
- /// If true attribute selects geometry instead of shape.
- bool myIsGeometricalSelection;
-
public:
/// Defines the result and its selected sub-shape
/// \param theContext object where the sub-shape was selected
void computeValues(ResultPtr theOldContext, ResultPtr theNewContext, TopoDS_Shape theValShape,
TopTools_ListOfShape& theShapes);
- /// Returns true if is geometrical selection.
- virtual bool isGeometricalSelection() const {
- return myIsGeometricalSelection;
- };
-
friend class Model_Data;
friend class Model_AttributeSelectionList;
};
// (if attribute is deleted and created, the abort updates attriute and makes the Attr invalid)
std::shared_ptr<Model_AttributeSelection> aNewAttr =
std::shared_ptr<Model_AttributeSelection>(new Model_AttributeSelection(aLabel));
+ aNewAttr->setID(id());
if (owner()) {
aNewAttr->setObject(owner());
aNewAttr->setParent(this);
}
- aNewAttr->setID(id());
return aNewAttr;
}
if (!aCases.empty()) {
validators()->registerCase(aMsgAttr->featureId(), aMsgAttr->attributeId(), aCases);
}
- if (aMsgAttr->isGeometricalSelection()) {
- validators()->registerGeometricalSelection(aMsgAttr->featureId(),
- aMsgAttr->attributeId());
- }
}
}
// plugins information was started to load, so, it will be loaded
std::map<std::string, std::string>::iterator aFound = myMainArgument.find(theFeature);
return aFound != myMainArgument.end() && aFound->second == theAttribute;
}
-
-void Model_ValidatorsFactory::registerGeometricalSelection(std::string theFeature,
- std::string theAttribute)
-{
- std::map<std::string, std::set<std::string> >::iterator aFind =
- myGeometricalSelection.find(theFeature);
- if (aFind == myGeometricalSelection.end()) {
- std::set<std::string> aNewSet;
- aNewSet.insert(theAttribute);
- myGeometricalSelection[theFeature] = aNewSet;
- }
- else {
- aFind->second.insert(theAttribute);
- }
-}
-
-bool Model_ValidatorsFactory::isGeometricalSelection(std::string theFeature,
- std::string theAttribute)
-{
- std::map<std::string, std::set<std::string> >::iterator aFind =
- myGeometricalSelection.find(theFeature);
- return aFind != myGeometricalSelection.end()
- && aFind->second.find(theAttribute) != aFind->second.end();
-}
std::map<std::string, std::set<std::string> > > > myCases;
/// Stores main attribute for each feature
std::map<std::string, std::string> myMainArgument;
- std::map<std::string, std::set<std::string> > myGeometricalSelection;
public:
/// Registers the instance of the validator by the ID
/// Returns true is the attribute is a main argument of the feature
virtual bool isMainArgument(std::string theFeature, std::string theAttribute);
- /// Register the selection attribute as geometrical selection
- virtual void registerGeometricalSelection(std::string theFeature, std::string theAttribute);
-
- /// Returns true if the attribute is a geometrical selection
- virtual bool isGeometricalSelection(std::string theFeature, std::string theAttribute);
-
protected:
/// Adds the defualt validators that are usefull for all features.
/// Returns true if recompute of selection become impossible
virtual bool isInvalid() = 0;
- /// Returns true if is geometrical selection.
- virtual bool isGeometricalSelection() const = 0;
-
/// To virtually destroy the fields of successors
MODELAPI_EXPORT virtual ~ModelAPI_AttributeSelection();
/// Returns true if the attribute must be checked (the case is selected)
virtual bool isCase(FeaturePtr theFeature, std::string theAttribute) = 0;
- /// Register the selection attribute as geometrical selection
- virtual void registerGeometricalSelection(std::string theFeature, std::string theAttribute) = 0;
-
- /// Returns true if the attribute is a geometrical selection
- virtual bool isGeometricalSelection(std::string theFeature, std::string theAttribute) = 0;
-
protected:
/// Get instance from Session
ModelAPI_ValidatorsFactory()
#include <GeomAPI_Pnt.h>
#include <GeomAPI_Dir.h>
#include <GeomAPI_ShapeExplorer.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAlgoAPI_NExplode.h>
#include <GeomDataAPI_Dir.h>
isDumpByGeom = aSelectedFeature && aSelectedFeature->isInHistory();
}
- if (theAttrSelect->isGeometricalSelection() && aShape->shapeType() == GeomAPI_Shape::COMPOUND) {
- GeomAPI_ShapeIterator anIt(aShape);
- aShape = anIt.current();
- }
-
myDumpBuffer << "\"" << aShape->shapeTypeStr();
bool aStandardDump = true;
if (isDumpByGeom) {
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
#include <GeomAPI_ShapeExplorer.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAlgoAPI_PointBuilder.h>
}
// Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
- std::shared_ptr<ModelAPI_AttributeSelection> anEdgeRef = selection(AXIS_ID());
- GeomShapePtr aShape = anEdgeRef->value();
- if (!aShape.get()) {
- if (anEdgeRef->context().get()) {
- aShape = anEdgeRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
- }
+ std::shared_ptr<GeomAPI_Ax2> anAxis;
std::shared_ptr<GeomAPI_Edge> anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
+ std::shared_ptr<ModelAPI_AttributeSelection> anEdgeRef =
+ selection(PrimitivesPlugin_Cone::AXIS_ID());
+ if(anEdgeRef && anEdgeRef->value() && anEdgeRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anEdgeRef->value()));
+ } else if (anEdgeRef && !anEdgeRef->value() && anEdgeRef->context() &&
+ anEdgeRef->context()->shape() && anEdgeRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anEdgeRef->context()->shape()));
}
- else
- {
- setError(aSelectionError);
- return;
+ if(anEdge) {
+ anAxis = std::shared_ptr<GeomAPI_Ax2>(new GeomAPI_Ax2(aBasePoint,
+ anEdge->line()->direction()));
}
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
- }
-
- std::shared_ptr<GeomAPI_Ax2> anAxis(new GeomAPI_Ax2(aBasePoint,
- anEdge->line()->direction()));
-
// Getting base radius, top radius and height
double aBaseRadius = real(PrimitivesPlugin_Cone::BASE_RADIUS_ID())->value();
double aTopRadius = real(PrimitivesPlugin_Cone::TOP_RADIUS_ID())->value();
#include <GeomAPI_Dir.h>
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAlgoAPI_PointBuilder.h>
}
// Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
- std::shared_ptr<ModelAPI_AttributeSelection> anEdgeRef = selection(AXIS_ID());
- GeomShapePtr aShape = anEdgeRef->value();
- if (!aShape.get()) {
- if (anEdgeRef->context().get()) {
- aShape = anEdgeRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
- }
+ std::shared_ptr<GeomAPI_Ax2> anAxis;
std::shared_ptr<GeomAPI_Edge> anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
- }
- else
- {
- setError(aSelectionError);
- return;
- }
-
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
+ std::shared_ptr<ModelAPI_AttributeSelection> anEdgeRef =
+ selection(PrimitivesPlugin_Cylinder::AXIS_ID());
+ if(anEdgeRef && anEdgeRef->value() && anEdgeRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anEdgeRef->value()));
+ } else if (anEdgeRef && !anEdgeRef->value() && anEdgeRef->context() &&
+ anEdgeRef->context()->shape() && anEdgeRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anEdgeRef->context()->shape()));
+ }
+ if(anEdge) {
+ anAxis = std::shared_ptr<GeomAPI_Ax2>(new GeomAPI_Ax2(aBasePoint,
+ anEdge->line()->direction()));
}
- std::shared_ptr<GeomAPI_Ax2> anAxis(new GeomAPI_Ax2(aBasePoint,
- anEdge->line()->direction()));
-
-
// Getting radius and height
double aRadius = real(PrimitivesPlugin_Cylinder::RADIUS_ID())->value();
double aHeight = real(PrimitivesPlugin_Cylinder::HEIGHT_ID())->value();
#include <GeomAPI_Edge.h>
#include <GeomAPI_Lin.h>
#include <GeomAPI_ShapeExplorer.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAlgoAPI_PointBuilder.h>
}
// Getting axis.
- static const std::string aSelectionError = "Error: The axis shape selection is bad.";
- std::shared_ptr<ModelAPI_AttributeSelection> anEdgeRef = selection(AXIS_ID());
- GeomShapePtr aShape = anEdgeRef->value();
- if (!aShape.get()) {
- if (anEdgeRef->context().get()) {
- aShape = anEdgeRef->context()->shape();
- }
- }
- if (!aShape.get()) {
- setError(aSelectionError);
- return;
- }
+ std::shared_ptr<GeomAPI_Ax2> anAxis;
std::shared_ptr<GeomAPI_Edge> anEdge;
- if (aShape->isEdge())
- {
- anEdge = aShape->edge();
- }
- else if (aShape->isCompound())
- {
- GeomAPI_ShapeIterator anIt(aShape);
- anEdge = anIt.current()->edge();
+ std::shared_ptr<ModelAPI_AttributeSelection> anEdgeRef =
+ selection(PrimitivesPlugin_Torus::AXIS_ID());
+ if(anEdgeRef && anEdgeRef->value() && anEdgeRef->value()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anEdgeRef->value()));
+ } else if (anEdgeRef && !anEdgeRef->value() && anEdgeRef->context() &&
+ anEdgeRef->context()->shape() && anEdgeRef->context()->shape()->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anEdgeRef->context()->shape()));
}
- else
- {
- setError(aSelectionError);
- return;
+ if(anEdge) {
+ anAxis = std::shared_ptr<GeomAPI_Ax2>(new GeomAPI_Ax2(aBasePoint,
+ anEdge->line()->direction()));
}
- if (!anEdge.get())
- {
- setError(aSelectionError);
- return;
- }
-
- std::shared_ptr<GeomAPI_Ax2> anAxis(new GeomAPI_Ax2(aBasePoint,
- anEdge->line()->direction()));
-
// Getting radius and ring radius
double aRadius = real(PrimitivesPlugin_Torus::RADIUS_ID())->value();
double aRingRadius = real(PrimitivesPlugin_Torus::RING_RADIUS_ID())->value();
label="axis"
default=""
shape_types="edge"
- geometrical_selection="true"
icon="icons/Primitives/axis.png"
tooltip="Select the axis of the cone">
<validator id="GeomValidators_ConstructionComposite"/>
label="axis"
default=""
shape_types="edge"
- geometrical_selection="true"
icon="icons/Primitives/axis.png"
tooltip="Select the axis of the cylinder">
<validator id="GeomValidators_ConstructionComposite"/>
label="axis"
default=""
shape_types="edge"
- geometrical_selection="true"
icon="icons/Primitives/axis.png"
tooltip="Select the axis of the cylinder">
<validator id="GeomValidators_ConstructionComposite"/>
label="axis"
default=""
shape_types="edge"
- geometrical_selection="true"
icon="icons/Primitives/axis.png"
tooltip="Select the axis of the torus">
<validator id="GeomValidators_ConstructionComposite"/>
#include <GeomAPI_Dir.h>
#include <GeomAPI_PlanarEdges.h>
-#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_Vertex.h>
#include <GeomDataAPI_Point2D.h>
std::shared_ptr<GeomAPI_Shape> aSelection = aSelAttr->value();
if (!aSelection.get()) aSelection = aSelAttr->context()->shape();
// update the sketch plane
- std::shared_ptr<GeomAPI_Face> aFace;
- if (aSelection->isFace()) {
- aFace = aSelection->face();
- } else if (aSelection->isCompound()) {
- GeomAPI_ShapeIterator anIt(aSelection);
- aFace = anIt.current()->face();
- }
-
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aSelection));
std::shared_ptr<GeomAPI_Pln> aPlane = aFace->getPlane();
if (aPlane) {
double anA, aB, aC, aD;
