-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include <GEOMImpl_ShapeDriver.hxx>
+#include <GEOMImpl_IExtract.hxx>
#include <GEOMImpl_IIsoline.hxx>
#include <GEOMImpl_IShapes.hxx>
#include <GEOMImpl_IShapeExtend.hxx>
#include <GEOM_Function.hxx>
#include <GEOMUtils_Hatcher.hxx>
#include <GEOMAlgo_State.hxx>
+#include <GEOMAlgo_Extractor.hxx>
// OCCT Includes
#include <ShapeFix_Wire.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Iterator.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_HSequenceOfShape.hxx>
#include <list>
+/**
+ * \brief This static function converts the list of shapes into an array
+ * of their IDs. If the input list is empty, null handle will be returned.
+ * this method doesn't check if a shape presents in theIndices map.
+ *
+ * \param theListOfShapes the list of shapes.
+ * \param theIndices the indexed map of shapes.
+ * \return the array of shape IDs.
+ */
+static Handle(TColStd_HArray1OfInteger) GetShapeIDs
+ (const TopTools_ListOfShape &theListOfShapes,
+ const TopTools_IndexedMapOfShape &theIndices)
+{
+ Handle(TColStd_HArray1OfInteger) aResult;
+
+ if (!theListOfShapes.IsEmpty()) {
+ const Standard_Integer aNbShapes = theListOfShapes.Extent();
+ TopTools_ListIteratorOfListOfShape anIter(theListOfShapes);
+ Standard_Integer i;
+
+ aResult = new TColStd_HArray1OfInteger(1, aNbShapes);
+
+ for (i = 1; anIter.More(); anIter.Next(), ++i) {
+ const TopoDS_Shape &aShape = anIter.Value();
+ const Standard_Integer anIndex = theIndices.FindIndex(aShape);
+
+ aResult->SetValue(i, anIndex);
+ }
+ }
+
+ return aResult;
+}
+
+namespace
+{
+ // check that compound includes only shapes of expected type
+ bool checkCompound( TopoDS_Shape& c, TopAbs_ShapeEnum t )
+ {
+ TopoDS_Iterator it( c, Standard_True, Standard_True );
+
+ // empty compound is OK only if we explicitly create a compound of shapes
+ bool result = true;
+
+ // => if expected type is TopAbs_SHAPE, we allow compound consisting of any shapes, this above check is enough
+ // => otherwise we have to check compound's content
+ // => compound sometimes can contain enclosed compound(s), we process them recursively and rebuild initial compound
+
+ if ( t != TopAbs_SHAPE ) {
+ result = it.More();
+ std::list<TopoDS_Shape> compounds, shapes;
+ compounds.push_back( c );
+ while ( !compounds.empty() && result ) {
+ // check that compound contains only shapes of expected type
+ TopoDS_Shape cc = compounds.front();
+ compounds.pop_front();
+ it.Initialize( cc, Standard_True, Standard_True );
+ for ( ; it.More() && result; it.Next() ) {
+ TopAbs_ShapeEnum tt = it.Value().ShapeType();
+ if ( tt == TopAbs_COMPOUND || tt == TopAbs_COMPSOLID ) {
+ compounds.push_back( it.Value() );
+ continue;
+ }
+ shapes.push_back( it.Value() );
+ result = tt == t;
+ }
+ }
+ if ( result ) {
+ if ( shapes.empty() ) {
+ result = false;
+ }
+ else if ( shapes.size() == 1 ) {
+ c = shapes.front();
+ }
+ else {
+ BRep_Builder b;
+ TopoDS_Compound newc;
+ b.MakeCompound( newc );
+ std::list<TopoDS_Shape> ::const_iterator sit;
+ for ( sit = shapes.begin(); sit != shapes.end(); ++sit )
+ b.Add( newc, *sit );
+ c = newc;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * This function adds faces from the input shape into the list of faces. If
+ * the input shape is a face, it is added itself. If it is a shell, its
+ * sub-shapes (faces) are added. If it is a compound, its sub-shapes
+ * (faces or shells) are added in the list. For null shapes and for other
+ * types of shapes an exception is thrown.
+ *
+ * @param theShape the shape to be added. Either face or shell or a compound
+ * of faces and/or shells.
+ * @param theListFaces the list of faces that is modified on output.
+ * @param theMapFence the map that protects from adding the same faces in
+ * the list.
+ */
+ void addFaces(const TopoDS_Shape &theShape,
+ TopTools_ListOfShape &theListFaces,
+ TopTools_MapOfShape &theMapFence)
+ {
+ if (theShape.IsNull()) {
+ Standard_NullObject::Raise("Face for shell construction is null");
+ }
+
+ // Append the shape is the mapFence
+ if (theMapFence.Add(theShape)) {
+ // Shape type
+ const TopAbs_ShapeEnum aType = theShape.ShapeType();
+
+ if (aType == TopAbs_FACE) {
+ theListFaces.Append(theShape);
+ } else if (aType == TopAbs_SHELL || aType == TopAbs_COMPOUND) {
+ TopoDS_Iterator anIter(theShape);
+
+ for (; anIter.More(); anIter.Next()) {
+ // Add sub-shapes: faces for shell or faces/shells for compound.
+ const TopoDS_Shape &aSubShape = anIter.Value();
+
+ addFaces(aSubShape, theListFaces, theMapFence);
+ }
+ } else {
+ Standard_TypeMismatch::Raise
+ ("Shape for shell construction is neither a shell nor a face");
+ }
+ }
+ }
+
+ /**
+ * This function constructs a shell or a compound of shells
+ * from a set of faces and/or shells.
+ *
+ * @param theShapes is a set of faces, shells and/or
+ * compounds of faces/shells.
+ * @return a shell or a compound of shells.
+ */
+ TopoDS_Shape makeShellFromFaces
+ (const Handle(TColStd_HSequenceOfTransient) &theShapes)
+ {
+ const Standard_Integer aNbShapes = theShapes->Length();
+ Standard_Integer i;
+ TopTools_ListOfShape aListFaces;
+ TopTools_MapOfShape aMapFence;
+ BRep_Builder aBuilder;
+
+ // Fill the list of unique faces
+ for (i = 1; i <= aNbShapes; ++i) {
+ // Function
+ const Handle(GEOM_Function) aRefShape =
+ Handle(GEOM_Function)::DownCast(theShapes->Value(i));
+
+ if (aRefShape.IsNull()) {
+ Standard_NullObject::Raise("Face for shell construction is null");
+ }
+
+ // Shape
+ const TopoDS_Shape aShape = aRefShape->GetValue();
+
+ addFaces(aShape, aListFaces, aMapFence);
+ }
+
+ // Perform computation of shells.
+ TopTools_ListOfShape aListShells;
+ TopTools_ListIteratorOfListOfShape anIter;
+
+ while (!aListFaces.IsEmpty()) {
+ // Perform sewing
+ BRepBuilderAPI_Sewing aSewing(Precision::Confusion()*10.0);
+
+ for (anIter.Initialize(aListFaces); anIter.More(); anIter.Next()) {
+ aSewing.Add(anIter.Value());
+ }
+
+ aSewing.Perform();
+
+ // Fill list of shells.
+ const TopoDS_Shape &aSewed = aSewing.SewedShape();
+ TopExp_Explorer anExp(aSewed, TopAbs_SHELL);
+ Standard_Boolean isNewShells = Standard_False;
+
+ // Append shells
+ for (; anExp.More(); anExp.Next()) {
+ aListShells.Append(anExp.Current());
+ isNewShells = Standard_True;
+ }
+
+ // Append single faces.
+ anExp.Init(aSewed, TopAbs_FACE, TopAbs_SHELL);
+
+ for (; anExp.More(); anExp.Next()) {
+ TopoDS_Shell aShell;
+
+ aBuilder.MakeShell(aShell);
+ aBuilder.Add(aShell, anExp.Current());
+ aListShells.Append(aShell);
+ isNewShells = Standard_True;
+ }
+
+ if (!isNewShells) {
+ // There are no more shell can be obtained. Break the loop.
+ break;
+ }
+
+ // Remove faces that are in the result from the list.
+ TopTools_IndexedMapOfShape aMapFaces;
+
+ TopExp::MapShapes(aSewed, TopAbs_FACE, aMapFaces);
+
+ // Add deleted faces to the map
+ const Standard_Integer aNbDelFaces = aSewing.NbDeletedFaces();
+
+ for (i = 1; i <= aNbDelFaces; ++i) {
+ aMapFaces.Add(aSewing.DeletedFace(i));
+ }
+
+ for (anIter.Initialize(aListFaces); anIter.More();) {
+ const TopoDS_Shape &aFace = anIter.Value();
+ Standard_Boolean isFaceUsed = Standard_False;
+
+ if (aMapFaces.Contains(aFace) || aSewing.IsModified(aFace)) {
+ // Remove face from the list.
+ aListFaces.Remove(anIter);
+ } else {
+ // Go to the next face.
+ anIter.Next();
+ }
+ }
+ }
+
+ // If there are faces not used in shells create a shell for each face.
+ for (anIter.Initialize(aListFaces); anIter.More(); anIter.Next()) {
+ TopoDS_Shell aShell;
+
+ aBuilder.MakeShell(aShell);
+ aBuilder.Add(aShell, anIter.Value());
+ aListShells.Append(aShell);
+ }
+
+ // Construct the result that can be either a shell or a compound of shells
+ TopoDS_Shape aResult;
+
+ if (!aListShells.IsEmpty()) {
+ if (aListShells.Extent() == 1) {
+ aResult = aListShells.First();
+ } else {
+ // There are more then one shell.
+ TopoDS_Compound aCompound;
+
+ aBuilder.MakeCompound(aCompound);
+
+ for (anIter.Initialize(aListShells); anIter.More(); anIter.Next()) {
+ aBuilder.Add(aCompound, anIter.Value());
+ }
+
+ aResult = aCompound;
+ }
+ }
+
+ return aResult;
+ }
+
+ // End of namespace
+}
+
//modified by NIZNHY-PKV Wed Dec 28 13:48:20 2011f
//static
// void KeepEdgesOrder(const Handle(TopTools_HSequenceOfShape)& aEdges,
//function : Execute
//purpose :
//=======================================================================
-Standard_Integer GEOMImpl_ShapeDriver::Execute(TFunction_Logbook& log) const
+Standard_Integer GEOMImpl_ShapeDriver::Execute(Handle(TFunction_Logbook)& log) const
{
if (Label().IsNull()) return 0;
Handle(GEOM_Function) aFunction = GEOM_Function::GetFunction(Label());
TopoDS_Shape aShape;
TCollection_AsciiString aWarning;
- std::list<TopAbs_ShapeEnum> anExpectedType;
+
+ // this is an exact type of expected shape, or shape in a compound if compound is allowed as a result (see below)
+ TopAbs_ShapeEnum anExpectedType = TopAbs_SHAPE;
+ // this should be true if result can be a compound of shapes of strict type (see above)
+ bool allowCompound = false;
BRep_Builder B;
if (aType == WIRE_EDGES) {
- anExpectedType.push_back(TopAbs_WIRE);
+ // result may be only a single wire
+ anExpectedType = TopAbs_WIRE;
Handle(TColStd_HSequenceOfTransient) aShapes = aCI.GetShapes();
aShape = MakeWireFromEdges(aShapes, aTolerance);
}
else if (aType == FACE_WIRE) {
- anExpectedType.push_back(TopAbs_FACE);
+ // result may be a face or a compound of faces
+ anExpectedType = TopAbs_FACE;
+ allowCompound = true;
Handle(GEOM_Function) aRefBase = aCI.GetBase();
TopoDS_Shape aShapeBase = aRefBase->GetValue();
}
}
else if (aType == FACE_WIRES) {
- anExpectedType.push_back(TopAbs_FACE);
+ // result may be a face or a compound of faces
+ anExpectedType = TopAbs_FACE;
+ allowCompound = true;
// Try to build a face from a set of wires and edges
int ind;
}
}
else if (aType == FACE_FROM_SURFACE) {
- anExpectedType.push_back(TopAbs_FACE);
+ // result may be only a face
+ anExpectedType = TopAbs_FACE;
Handle(TColStd_HSequenceOfTransient) aShapes = aCI.GetShapes();
}
}
else if (aType == SHELL_FACES) {
- anExpectedType.push_back(TopAbs_SHELL);
+ // result may be only a shell or a compound of shells
+ anExpectedType = TopAbs_SHELL;
+ allowCompound = true;
Handle(TColStd_HSequenceOfTransient) aShapes = aCI.GetShapes();
- unsigned int ind, nbshapes = aShapes->Length();
- // add faces
- BRepBuilderAPI_Sewing aSewing (Precision::Confusion()*10.0);
- for (ind = 1; ind <= nbshapes; ind++) {
- Handle(GEOM_Function) aRefShape = Handle(GEOM_Function)::DownCast(aShapes->Value(ind));
- TopoDS_Shape aShape_i = aRefShape->GetValue();
- if (aShape_i.IsNull()) {
- Standard_NullObject::Raise("Face for shell construction is null");
- }
- aSewing.Add(aShape_i);
- }
-
- aSewing.Perform();
-
- TopoDS_Shape sh = aSewing.SewedShape();
-
- if (sh.ShapeType()==TopAbs_FACE && nbshapes==1) {
- // case for creation of shell from one face - PAL12722 (skl 26.06.2006)
- TopoDS_Shell ss;
- B.MakeShell(ss);
- B.Add(ss,sh);
- aShape = ss;
- }
- else {
- //TopExp_Explorer exp (aSewing.SewedShape(), TopAbs_SHELL);
- TopExp_Explorer exp (sh, TopAbs_SHELL);
- Standard_Integer ish = 0;
- for (; exp.More(); exp.Next()) {
- aShape = exp.Current();
- ish++;
- }
-
- if (ish != 1) {
- // try the case of one face (Mantis issue 0021809)
- TopExp_Explorer expF (sh, TopAbs_FACE);
- Standard_Integer ifa = 0;
- for (; expF.More(); expF.Next()) {
- aShape = expF.Current();
- ifa++;
- }
-
- if (ifa == 1) {
- TopoDS_Shell ss;
- B.MakeShell(ss);
- B.Add(ss,aShape);
- aShape = ss;
- }
- else {
- aShape = aSewing.SewedShape();
- }
- }
+ if (aShapes.IsNull()) {
+ Standard_NullObject::Raise("Argument Shapes is null");
}
+ // Compute a shell or a compound of shells.
+ aShape = makeShellFromFaces(aShapes);
}
else if (aType == SOLID_SHELLS) {
- anExpectedType.push_back(TopAbs_SOLID);
+ // result may be only a solid or a compound of solids
+ anExpectedType = TopAbs_SOLID;
+ allowCompound = true;
Handle(TColStd_HSequenceOfTransient) aShapes = aCI.GetShapes();
unsigned int ind, nbshapes = aShapes->Length();
aShape = Sol;
}
else if (aType == COMPOUND_SHAPES) {
- anExpectedType.push_back(TopAbs_COMPOUND);
+ // result may be only a compound of any shapes
+ allowCompound = true;
Handle(TColStd_HSequenceOfTransient) aShapes = aCI.GetShapes();
unsigned int ind, nbshapes = aShapes->Length();
}
else if (aType == EDGE_WIRE) {
- anExpectedType.push_back(TopAbs_EDGE);
+ // result may be only an edge
+ anExpectedType = TopAbs_EDGE;
Handle(GEOM_Function) aRefBase = aCI.GetBase();
TopoDS_Shape aWire = aRefBase->GetValue();
aShape = MakeEdgeFromWire(aWire, LinTol, AngTol);
}
else if (aType == SOLID_FACES) {
- anExpectedType.push_back(TopAbs_SOLID);
- anExpectedType.push_back(TopAbs_COMPOUND);
- anExpectedType.push_back(TopAbs_COMPSOLID);
+ // result may be only a solid or a compound of solids
+ anExpectedType = TopAbs_SOLID;
+ allowCompound = true;
Handle(TColStd_HSequenceOfTransient) aShapes = aCI.GetShapes();
unsigned int ind, nbshapes = aShapes->Length();
aMV.SetArguments(aLS);
aMV.SetIntersect(aCI.GetIsIntersect());
aMV.Perform();
- if (aMV.ErrorStatus()) return 0;
+ if (aMV.HasErrors()) return 0;
aShape = aMV.Shape();
}
else if (aType == EDGE_CURVE_LENGTH) {
- anExpectedType.push_back(TopAbs_EDGE);
+ // result may be only an edge
+ anExpectedType = TopAbs_EDGE;
GEOMImpl_IVector aVI (aFunction);
BRepBuilderAPI_MakeEdge aME (ReOrientedCurve, UFirst, aParam);
if (aME.IsDone())
aShape = aME.Shape();
- } else if (aType == SHAPE_ISOLINE) {
+ }
+ else if (aType == SHAPE_ISOLINE) {
+ // result may be only an edge or compound of edges
+ anExpectedType = TopAbs_EDGE;
+ allowCompound = true;
+
GEOMImpl_IIsoline aII (aFunction);
Handle(GEOM_Function) aRefFace = aII.GetFace();
TopoDS_Shape aShapeFace = aRefFace->GetValue();
Standard_NullObject::Raise
("Shape for isoline construction is not a face");
}
- } else if (aType == EDGE_UV) {
- anExpectedType.push_back(TopAbs_EDGE);
+ }
+ else if (aType == EDGE_UV) {
+ // result may be only an edge
+ anExpectedType = TopAbs_EDGE;
+
GEOMImpl_IShapeExtend aSE (aFunction);
Handle(GEOM_Function) aRefEdge = aSE.GetShape();
TopoDS_Shape aShapeEdge = aRefEdge->GetValue();
aShape = ExtendEdge(anEdge, aSE.GetUMin(), aSE.GetUMax());
}
- } else if (aType == FACE_UV) {
- anExpectedType.push_back(TopAbs_FACE);
+ }
+ else if (aType == FACE_UV) {
+ // result may be only a face
+ anExpectedType = TopAbs_FACE;
GEOMImpl_IShapeExtend aSE (aFunction);
Handle(GEOM_Function) aRefFace = aSE.GetShape();
aShape = ExtendFace(aFace, aSE.GetUMin(), aSE.GetUMax(),
aSE.GetVMin(), aSE.GetVMax());
}
- } else if (aType == SURFACE_FROM_FACE) {
- anExpectedType.push_back(TopAbs_FACE);
+ }
+ else if (aType == SURFACE_FROM_FACE) {
+ // result may be only a face
+ anExpectedType = TopAbs_FACE;
GEOMImpl_IShapeExtend aSE (aFunction);
Handle(GEOM_Function) aRefFace = aSE.GetShape();
}
}
}
+ } else if (aType == EXTRACTION) {
+ allowCompound = true;
+
+ GEOMImpl_IExtract aCI(aFunction);
+ Handle(GEOM_Function) aRefShape = aCI.GetShape();
+ TopoDS_Shape aShapeBase = aRefShape->GetValue();
+
+ if (aShapeBase.IsNull()) {
+ Standard_NullObject::Raise("Argument Shape is null");
+ return 0;
+ }
+
+ Handle(TColStd_HArray1OfInteger) anIDs = aCI.GetSubShapeIDs();
+ TopTools_ListOfShape aListSubShapes;
+ TopTools_IndexedMapOfShape anIndices;
+ int i;
+
+ TopExp::MapShapes(aShapeBase, anIndices);
+
+ if (!anIDs.IsNull()) {
+ const int anUpperID = anIDs->Upper();
+ const int aNbShapes = anIndices.Extent();
+
+ for (i = anIDs->Lower(); i <= anUpperID; ++i) {
+ const Standard_Integer anIndex = anIDs->Value(i);
+
+ if (anIndex < 1 || anIndex > aNbShapes) {
+ TCollection_AsciiString aMsg(" Invalid index: ");
+
+ aMsg += TCollection_AsciiString(anIndex);
+ StdFail_NotDone::Raise(aMsg.ToCString());
+ return 0;
+ }
+
+ const TopoDS_Shape &aSubShape = anIndices.FindKey(anIndex);
+
+ aListSubShapes.Append(aSubShape);
+ }
+ }
+
+ // Compute extraction.
+ GEOMAlgo_Extractor anExtractor;
+
+ anExtractor.SetShape(aShapeBase);
+ anExtractor.SetShapesToRemove(aListSubShapes);
+
+ anExtractor.Perform();
+
+ // Interprete results
+ Standard_Integer iErr = anExtractor.ErrorStatus();
+
+ // The detailed description of error codes is in GEOMAlgo_Extractor.cxx
+ if (iErr) {
+ TCollection_AsciiString aMsg(" iErr : ");
+
+ aMsg += TCollection_AsciiString(iErr);
+ StdFail_NotDone::Raise(aMsg.ToCString());
+ return 0;
+ }
+
+ aShape = anExtractor.GetResult();
+
+ if (aShape.IsNull()) {
+ Standard_ConstructionError::Raise("Result of extraction is empty");
+ }
+
+ // Get statistics.
+ const TopTools_ListOfShape &aRemoved = anExtractor.GetRemoved();
+ const TopTools_ListOfShape &aModified = anExtractor.GetModified();
+ const TopTools_ListOfShape &aNew = anExtractor.GetNew();
+ Handle(TColStd_HArray1OfInteger) aRemovedIDs =
+ GetShapeIDs(aRemoved, anIndices);
+ Handle(TColStd_HArray1OfInteger) aModifiedIDs =
+ GetShapeIDs(aModified, anIndices);
+ Handle(TColStd_HArray1OfInteger) aNewIDs;
+
+ if (!aShape.IsNull()) {
+ // Get newly created sub-shapes
+ TopTools_IndexedMapOfShape aNewIndices;
+
+ TopExp::MapShapes(aShape, aNewIndices);
+ aNewIDs = GetShapeIDs(aNew, aNewIndices);
+ }
+
+ if (!aRemovedIDs.IsNull()) {
+ aCI.SetRemovedIDs(aRemovedIDs);
+ }
+
+ if (!aModifiedIDs.IsNull()) {
+ aCI.SetModifiedIDs(aModifiedIDs);
+ }
+
+ if (!aNewIDs.IsNull()) {
+ aCI.SetAddedIDs(aNewIDs);
+ }
}
else {
}
if (aShape.IsNull()) return 0;
// Check shape validity
- BRepCheck_Analyzer ana (aShape, false);
+ BRepCheck_Analyzer ana (aShape, true);
if (!ana.IsValid()) {
//Standard_ConstructionError::Raise("Algorithm have produced an invalid shape result");
// For Mantis issue 0021772: EDF 2336 GEOM: Non valid face created from two circles
aShape = aSfs->Shape();
}
- // Check if the result shape type is compatible with the expected.
+ // Check if the result shape is of expected type.
const TopAbs_ShapeEnum aShType = aShape.ShapeType();
- if (!anExpectedType.empty()) {
- bool ok = false;
- std::list<TopAbs_ShapeEnum>::const_iterator it;
- for (it = anExpectedType.begin(); it != anExpectedType.end() && !ok; ++it)
- ok = (*it == TopAbs_SHAPE || *it == aShType);
- if (!ok)
- Standard_ConstructionError::Raise("Result type check failed");
+ bool ok = false;
+ if ( aShType == TopAbs_COMPOUND || aShType == TopAbs_COMPSOLID ) {
+ ok = allowCompound && checkCompound( aShape, anExpectedType );
+ }
+ else {
+ ok = ( anExpectedType == TopAbs_SHAPE ) || ( aShType == anExpectedType );
}
+ if (!ok)
+ Standard_ConstructionError::Raise("Result type check failed");
aFunction->SetValue(aShape);
- log.SetTouched(Label());
+ log->SetTouched(Label());
if (!aWarning.IsEmpty())
Standard_Failure::Raise(aWarning.ToCString());
{
Standard_Boolean Done = Standard_False;
Standard_Real NewFpar, NewLpar;
- GeomAdaptor_Curve GAprevcurve(CurveSeq.Last());
+ Handle(Geom_Geometry) aTrsfGeom = CurveSeq.Last()->Transformed
+ (LocSeq.Last().Location().Transformation());
+ GeomAdaptor_Curve GAprevcurve(Handle(Geom_Curve)::DownCast(aTrsfGeom));
TopoDS_Vertex CurVertex = wexp.CurrentVertex();
TopoDS_Vertex CurFirstVer = TopExp::FirstVertex(anEdge);
TopAbs_Orientation ConnectByOrigin = (CurVertex.IsSame(CurFirstVer))? TopAbs_FORWARD : TopAbs_REVERSED;
- if (aCurve == CurveSeq.Last())
+ if (aCurve == CurveSeq.Last() && aLoc.IsEqual(LocSeq.Last().Location()))
{
NewFpar = fpar;
NewLpar = lpar;
if (closed_flag) {
// Check if closed curve is reordered.
- Handle(Geom_Curve) aCurve = concatcurve->Value(concatcurve->Lower());
+ Handle(Geom_BSplineCurve) aCurve = concatcurve->Value(concatcurve->Lower());
Standard_Real aFPar = aCurve->FirstParameter();
gp_Pnt aPFirst;
gp_Pnt aPntVtx = BRep_Tool::Pnt(FirstVertex);
AddParam(theParams, "Face", aSE.GetShape());
break;
}
+ case EXTRACTION:
+ {
+ GEOMImpl_IExtract aCI (function);
+
+ theOperationName = "EXTRACTION";
+ AddParam(theParams, "Main Shape", aCI.GetShape());
+ AddParam(theParams, "Sub-shape IDs", aCI.GetSubShapeIDs());
+ break;
+ }
default:
return false;
}
return true;
}
-IMPLEMENT_STANDARD_HANDLE (GEOMImpl_ShapeDriver,GEOM_BaseDriver);
IMPLEMENT_STANDARD_RTTIEXT (GEOMImpl_ShapeDriver,GEOM_BaseDriver);
//modified by NIZNHY-PKV Wed Dec 28 13:48:31 2011f
