-// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2020 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
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// File : GEOMImpl_IShapesOperations.cxx
-// Created :
-// Author : modified by Lioka RAZAFINDRAZAKA (CEA) 22/06/2007
-// Project : SALOME
-// $Header$
-//
-#include <Standard_Stream.hxx>
+
+// File : GEOMImpl_IShapesOperations.cxx
+// Created :
+// Author : modified by Lioka RAZAFINDRAZAKA (CEA) 22/06/2007
+// Project : SALOME
+
+//#include <Standard_Stream.hxx>
#include "GEOMImpl_IShapesOperations.hxx"
#include "GEOMImpl_VectorDriver.hxx"
#include "GEOMImpl_ShapeDriver.hxx"
-#include "GEOMImpl_CopyDriver.hxx"
#include "GEOMImpl_GlueDriver.hxx"
+#include "GEOMImpl_FillingDriver.hxx"
+#include "GEOMImpl_IExtract.hxx"
#include "GEOMImpl_IVector.hxx"
#include "GEOMImpl_IShapes.hxx"
+#include "GEOMImpl_IShapeExtend.hxx"
#include "GEOMImpl_IGlue.hxx"
+#include "GEOMImpl_IFilling.hxx"
#include "GEOMImpl_Block6Explorer.hxx"
+#include "GEOMImpl_IHealingOperations.hxx"
+
+#include "GEOMImpl_Gen.hxx"
#include "GEOM_Function.hxx"
#include "GEOM_ISubShape.hxx"
#include "GEOM_PythonDump.hxx"
-#include "GEOMAlgo_FinderShapeOn1.hxx"
-#include "GEOMAlgo_FinderShapeOnQuad.hxx"
-#include "GEOMAlgo_FinderShapeOn2.hxx"
+#include "GEOMUtils.hxx"
+
#include "GEOMAlgo_ClsfBox.hxx"
+#include "GEOMAlgo_ClsfQuad.hxx"
#include "GEOMAlgo_ClsfSolid.hxx"
-#include "GEOMAlgo_Gluer1.hxx"
-#include "GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx"
-#include "GEOMAlgo_CoupleOfShapes.hxx"
-#include "GEOMAlgo_ListOfCoupleOfShapes.hxx"
-
-#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
-
-#include <TFunction_DriverTable.hxx>
-#include <TFunction_Driver.hxx>
-#include <TFunction_Logbook.hxx>
-#include <TDataStd_Integer.hxx>
-#include <TDataStd_IntegerArray.hxx>
-#include <TDF_Tool.hxx>
+#include "GEOMAlgo_ClsfSurf.hxx"
+#include "GEOMAlgo_FinderShapeOn2.hxx"
+#include "GEOMAlgo_GetInPlace.hxx"
+#include "GEOMAlgo_GetInPlaceAPI.hxx"
+#include "GEOMAlgo_GlueDetector.hxx"
-#include <BRepExtrema_ExtCF.hxx>
-#include <BRepExtrema_DistShapeShape.hxx>
+#include <utilities.h>
-#include <BRep_Tool.hxx>
-#include <BRep_Builder.hxx>
-#include <BRepTools.hxx>
-#include <BRepGProp.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>
-#include <BRepBndLib.hxx>
-#include <BRepBuilderAPI_MakeFace.hxx>
-#include <BRepMesh_IncrementalMesh.hxx>
-
-#include <TopAbs.hxx>
+#include <BRepTools.hxx>
+#include <BRep_Builder.hxx>
+#include <BRep_Tool.hxx>
+#include <GeomLib_Tool.hxx>
+#include <Geom_CylindricalSurface.hxx>
+#include <Geom_Plane.hxx>
+#include <Geom_SphericalSurface.hxx>
+#include <Geom_Surface.hxx>
+#include <Geom_TrimmedCurve.hxx>
+#include <Precision.hxx>
+#include <TDF_Tool.hxx>
+#include <TDataStd_Integer.hxx>
+#include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_MapOfOrientedShape.hxx>
+#include <TopTools_MapOfShape.hxx>
+#include <TopTools_SequenceOfShape.hxx>
#include <TopoDS.hxx>
+#include <TopoDS_TShape.hxx>
+#include <TopoDS_Compound.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Solid.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
-#include <TopoDS_Compound.hxx>
-#include <TopoDS_Iterator.hxx>
-#include <TopExp_Explorer.hxx>
-#include <TopLoc_Location.hxx>
-#include <TopTools_MapOfShape.hxx>
-#include <TopTools_MapOfOrientedShape.hxx>
-#include <TopTools_Array1OfShape.hxx>
-#include <TopTools_ListIteratorOfListOfShape.hxx>
-#include <TopTools_IndexedMapOfShape.hxx>
-
-#include <Geom_Surface.hxx>
-#include <Geom_Plane.hxx>
-#include <Geom_SphericalSurface.hxx>
-#include <Geom_CylindricalSurface.hxx>
-#include <GeomAdaptor_Surface.hxx>
-
-#include <GeomLib_Tool.hxx>
-#include <Geom2d_Curve.hxx>
-
-#include <Bnd_Box.hxx>
-#include <GProp_GProps.hxx>
+#include <gp_Cylinder.hxx>
#include <gp_Pnt.hxx>
-#include <gp_Lin.hxx>
-#include <TColStd_ListOfInteger.hxx>
-#include <TColStd_ListIteratorOfListOfInteger.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_HArray1OfInteger.hxx>
#include <vector>
-#include <Standard_NullObject.hxx>
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
-// Includes added for GetInPlace algorithm improvement
+// VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+// Next macro, when defined, causes appearing of SubShapeAllIDs(), SubShapeAllSortedIDs(), GetSameIDs()
+// and other such commands in Python dump.
+// See also GEOM_Engine.cxx.
+// ---------------------------------------
+// #define DUMP_SUBSHAPE_IDS
+// ---------------------------------------
-#include <GEOMImpl_MeasureDriver.hxx>
-#include <GEOMImpl_IMeasure.hxx>
-#include <BRepBuilderAPI_MakeVertex.hxx>
+namespace {
-#include <BRepClass_FaceClassifier.hxx>
-#include <BRepClass3d_SolidClassifier.hxx>
-#include <Precision.hxx>
+ void AddFlatSubShapes(const TopoDS_Shape& S, TopTools_ListOfShape& L, TopTools_MapOfShape& M)
+ {
+ if (S.ShapeType() != TopAbs_COMPOUND) {
+ L.Append(S);
+ }
+ else {
+ TopoDS_Iterator It(S, Standard_True, Standard_True);
+ for (; It.More(); It.Next()) {
+ TopoDS_Shape SS = It.Value();
+ if (M.Add(SS))
+ AddFlatSubShapes(SS, L, M);
+ }
+ }
+ }
+}
+
+namespace
+{
+ const double MAX_TOLERANCE = 1.e-7;
+
+ /**
+ * \brief Returns the vertex from theWhere shape that is coincident with
+ * theVertex.
+ *
+ * \param theWhere the shape where the coincident vertex is searched.
+ * \param theVertex the vertex to be searched.
+ * \return the coincident vertex if it is found. Otherwise null object.
+ */
+ static TopoDS_Vertex getSameVertex(const TopoDS_Shape &theWhere,
+ const TopoDS_Vertex &theVertex)
+ {
+ TopoDS_Vertex aResult;
+ gp_Pnt aPoint = BRep_Tool::Pnt(theVertex);
+ TopExp_Explorer anExp(theWhere, TopAbs_VERTEX);
+ TopTools_MapOfShape aMap;
+
+ for(; anExp.More(); anExp.Next()) {
+ const TopoDS_Shape &aLocalShape = anExp.Current();
+
+ if(!aMap.Add(aLocalShape)) {
+ continue;
+ }
+
+ TopoDS_Vertex aVertex = TopoDS::Vertex(aLocalShape);
+ gp_Pnt aPoint2 = BRep_Tool::Pnt(aVertex);
+
+ if(aPoint.Distance(aPoint2) <= MAX_TOLERANCE) {
+ aResult = aVertex;
+ break;
+ }
+ }
+
+ return aResult;
+ }
+} // end of namespace
//=============================================================================
/*!
* constructor:
*/
//=============================================================================
-GEOMImpl_IShapesOperations::GEOMImpl_IShapesOperations (GEOM_Engine* theEngine, int theDocID)
-: GEOM_IOperations(theEngine, theDocID)
+GEOMImpl_IShapesOperations::GEOMImpl_IShapesOperations (GEOM_Engine* theEngine)
+: GEOM_IOperations(theEngine)
{
MESSAGE("GEOMImpl_IShapesOperations::GEOMImpl_IShapesOperations");
}
if (thePnt1.IsNull() || thePnt2.IsNull()) return NULL;
//Add a new Edge object
- Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GetDocID(), GEOM_EDGE);
+ Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GEOM_EDGE);
//Add a new Vector function
Handle(GEOM_Function) aFunction =
//Compute the Edge value
try {
-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Vector driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//=============================================================================
/*!
- * MakeWire
+ * MakeEdgeOnCurveByLength
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeWire
- (std::list<Handle(GEOM_Object)> theShapes)
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeEdgeOnCurveByLength
+ (Handle(GEOM_Object) theRefCurve,
+ const Standard_Real theLength,
+ Handle(GEOM_Object) theStartPoint)
{
- return MakeShape(theShapes, GEOM_WIRE, WIRE_EDGES, "MakeWire");
+ SetErrorCode(KO);
+
+ if (theRefCurve.IsNull()) return NULL;
+
+ //Add a new Edge object
+ Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GEOM_EDGE);
+
+ //Add a new Vector function
+ Handle(GEOM_Function) aFunction =
+ anEdge->AddFunction(GEOMImpl_ShapeDriver::GetID(), EDGE_CURVE_LENGTH);
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) return NULL;
+
+ GEOMImpl_IVector aPI (aFunction);
+
+ Handle(GEOM_Function) aRef1 = theRefCurve->GetLastFunction();
+ if (aRef1.IsNull()) return NULL;
+ aPI.SetPoint1(aRef1);
+
+ if (!theStartPoint.IsNull()) {
+ Handle(GEOM_Function) aRef2 = theStartPoint->GetLastFunction();
+ aPI.SetPoint2(aRef2);
+ }
+
+ aPI.SetParameter(theLength);
+
+ //Compute the Edge value
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Vector driver failed");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return NULL;
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump(aFunction) << anEdge << " = geompy.MakeEdgeOnCurveByLength("
+ << theRefCurve << ", " << theLength << ", " << theStartPoint << ")";
+
+ SetErrorCode(OK);
+ return anEdge;
}
//=============================================================================
/*!
- * MakeFace
+ * MakeEdgeWire
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeFace (Handle(GEOM_Object) theWire,
- const bool isPlanarWanted)
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeEdgeWire
+ (Handle(GEOM_Object) theWire,
+ const Standard_Real theLinearTolerance,
+ const Standard_Real theAngularTolerance)
{
SetErrorCode(KO);
if (theWire.IsNull()) return NULL;
- //Add a new Face object
- Handle(GEOM_Object) aFace = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
+ //Add a new Edge object
+ Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GEOM_EDGE);
- //Add a new Shape function for creation of a face from a wire
+ //Add a new Vector function
Handle(GEOM_Function) aFunction =
- aFace->AddFunction(GEOMImpl_ShapeDriver::GetID(), FACE_WIRE);
- if (aFunction.IsNull()) return NULL;
+ anEdge->AddFunction(GEOMImpl_ShapeDriver::GetID(), EDGE_WIRE);
//Check if the function is set correctly
if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) return NULL;
GEOMImpl_IShapes aCI (aFunction);
- Handle(GEOM_Function) aRefWire = theWire->GetLastFunction();
+ Handle(GEOM_Function) aWire = theWire->GetLastFunction();
- if (aRefWire.IsNull()) return NULL;
+ if (aWire.IsNull()) return NULL;
- aCI.SetBase(aRefWire);
- aCI.SetIsPlanar(isPlanarWanted);
+ aCI.SetBase(aWire);
+ aCI.SetTolerance(theLinearTolerance);
+ aCI.SetAngularTolerance(theAngularTolerance);
- //Compute the Face value
+ //Compute the Edge value
try {
-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
- SetErrorCode("Shape driver failed to compute a face");
+ SetErrorCode("Shape driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
+ const double DEF_LIN_TOL = Precision::Confusion();
+ const double DEF_ANG_TOL = Precision::Angular();
//Make a Python command
- GEOM::TPythonDump(aFunction) << aFace << " = geompy.MakeFace("
- << theWire << ", " << (int)isPlanarWanted << ")";
+ if ( theAngularTolerance == DEF_ANG_TOL ) {
+ if ( theLinearTolerance == DEF_LIN_TOL )
+ GEOM::TPythonDump(aFunction) << anEdge << " = geompy.MakeEdgeWire("
+ << theWire << ")";
+ else
+ GEOM::TPythonDump(aFunction) << anEdge << " = geompy.MakeEdgeWire("
+ << theWire << ", " << theLinearTolerance << ")";
+ }
+ else {
+ GEOM::TPythonDump(aFunction) << anEdge << " = geompy.MakeEdgeWire("
+ << theWire << ", " << theLinearTolerance << ", "
+ << theAngularTolerance << ")";
+ }
SetErrorCode(OK);
- return aFace;
+ return anEdge;
}
//=============================================================================
/*!
- * MakeFaceWires
+ * MakeWire
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeFaceWires
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeWire
(std::list<Handle(GEOM_Object)> theShapes,
- const bool isPlanarWanted)
+ const Standard_Real theTolerance)
{
SetErrorCode(KO);
//Add a new object
- Handle(GEOM_Object) aShape = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
+ Handle(GEOM_Object) aWire = GetEngine()->AddObject(GEOM_WIRE);
//Add a new function
Handle(GEOM_Function) aFunction =
- aShape->AddFunction(GEOMImpl_ShapeDriver::GetID(), FACE_WIRES);
+ aWire->AddFunction(GEOMImpl_ShapeDriver::GetID(), WIRE_EDGES);
if (aFunction.IsNull()) return NULL;
//Check if the function is set correctly
if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) return NULL;
GEOMImpl_IShapes aCI (aFunction);
+ aCI.SetTolerance(theTolerance);
Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient;
for (; it != theShapes.end(); it++) {
Handle(GEOM_Function) aRefSh = (*it)->GetLastFunction();
if (aRefSh.IsNull()) {
- SetErrorCode("NULL argument shape for the face construction");
+ SetErrorCode("NULL argument shape for the shape construction");
return NULL;
}
aShapesSeq->Append(aRefSh);
}
aCI.SetShapes(aShapesSeq);
- aCI.SetIsPlanar(isPlanarWanted);
-
//Compute the shape
try {
-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Shape driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Make a Python command
GEOM::TPythonDump pd (aFunction);
- pd << aShape << " = geompy.MakeFaceWires([";
+ pd << aWire << " = geompy.MakeWire([";
// Shapes
it = theShapes.begin();
pd << ", " << (*it++);
}
}
- pd << "], " << (int)isPlanarWanted << ")";
+ pd << "], " << theTolerance << ")";
SetErrorCode(OK);
- return aShape;
-}
-
-//=============================================================================
-/*!
- * MakeShell
- */
-//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeShell
- (std::list<Handle(GEOM_Object)> theShapes)
-{
- return MakeShape(theShapes, GEOM_SHELL, SHELL_FACES, "MakeShell");
-}
-
-//=============================================================================
-/*!
- * MakeSolidShells
- */
-//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeSolidShells
- (std::list<Handle(GEOM_Object)> theShapes)
-{
- return MakeShape(theShapes, GEOM_SOLID, SOLID_SHELLS, "MakeSolid");
+ return aWire;
}
//=============================================================================
/*!
- * MakeSolidShell
+ * MakeFace
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeSolidShell (Handle(GEOM_Object) theShell)
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeFace (Handle(GEOM_Object) theWire,
+ const bool isPlanarWanted)
{
SetErrorCode(KO);
- if (theShell.IsNull()) return NULL;
+ if (theWire.IsNull()) return NULL;
- //Add a new Solid object
- Handle(GEOM_Object) aSolid = GetEngine()->AddObject(GetDocID(), GEOM_SOLID);
+ //Add a new Face object
+ Handle(GEOM_Object) aFace = GetEngine()->AddObject(GEOM_FACE);
- //Add a new Solid function for creation of a solid from a shell
+ //Add a new Shape function for creation of a face from a wire
Handle(GEOM_Function) aFunction =
- aSolid->AddFunction(GEOMImpl_ShapeDriver::GetID(), SOLID_SHELL);
+ aFace->AddFunction(GEOMImpl_ShapeDriver::GetID(), FACE_WIRE);
if (aFunction.IsNull()) return NULL;
//Check if the function is set correctly
GEOMImpl_IShapes aCI (aFunction);
- Handle(GEOM_Function) aRefShell = theShell->GetLastFunction();
+ Handle(GEOM_Function) aRefWire = theWire->GetLastFunction();
- if (aRefShell.IsNull()) return NULL;
+ if (aRefWire.IsNull()) return NULL;
- aCI.SetBase(aRefShell);
+ aCI.SetBase(aRefWire);
+ aCI.SetIsPlanar(isPlanarWanted);
- //Compute the Solid value
+ //Compute the Face value
+ Standard_Boolean isWarning = Standard_False;
try {
-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
- SetErrorCode("Solid driver failed");
+ SetErrorCode("Shape driver failed to compute a face");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
- return NULL;
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ // to provide warning
+ if (!aFunction->GetValue().IsNull()) {
+ isWarning = Standard_True;
+ } else {
+ return NULL;
+ }
}
//Make a Python command
- GEOM::TPythonDump(aFunction) << aSolid
- << " = geompy.MakeSolid(" << theShell << ")";
-
- SetErrorCode(OK);
- return aSolid;
-}
+ GEOM::TPythonDump(aFunction) << aFace << " = geompy.MakeFace("
+ << theWire << ", " << (int)isPlanarWanted << ")";
-//=============================================================================
-/*!
- * MakeCompound
- */
-//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeCompound
- (std::list<Handle(GEOM_Object)> theShapes)
-{
- return MakeShape(theShapes, GEOM_COMPOUND, COMPOUND_SHAPES, "MakeCompound");
+ // to provide warning
+ if (!isWarning) SetErrorCode(OK);
+ return aFace;
}
//=============================================================================
/*!
- * MakeShape
+ * MakeFaceWires
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeShape
- (std::list<Handle(GEOM_Object)> theShapes,
- const Standard_Integer theObjectType,
- const Standard_Integer theFunctionType,
- const TCollection_AsciiString& theMethodName)
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeFaceWires
+ (std::list<Handle(GEOM_Object)> theShapes,
+ const bool isPlanarWanted)
{
SetErrorCode(KO);
//Add a new object
- Handle(GEOM_Object) aShape = GetEngine()->AddObject(GetDocID(), theObjectType);
+ Handle(GEOM_Object) aShape = GetEngine()->AddObject(GEOM_FACE);
//Add a new function
Handle(GEOM_Function) aFunction =
- aShape->AddFunction(GEOMImpl_ShapeDriver::GetID(), theFunctionType);
+ aShape->AddFunction(GEOMImpl_ShapeDriver::GetID(), FACE_WIRES);
if (aFunction.IsNull()) return NULL;
//Check if the function is set correctly
for (; it != theShapes.end(); it++) {
Handle(GEOM_Function) aRefSh = (*it)->GetLastFunction();
if (aRefSh.IsNull()) {
- SetErrorCode("NULL argument shape for the shape construction");
+ SetErrorCode("NULL argument shape for the face construction");
return NULL;
}
aShapesSeq->Append(aRefSh);
}
aCI.SetShapes(aShapesSeq);
+ aCI.SetIsPlanar(isPlanarWanted);
+
//Compute the shape
+ Standard_Boolean isWarning = Standard_False;
try {
-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Shape driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
- return NULL;
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ // to provide warning
+ if (!aFunction->GetValue().IsNull()) {
+ isWarning = Standard_True;
+ } else {
+ return NULL;
+ }
}
//Make a Python command
GEOM::TPythonDump pd (aFunction);
- pd << aShape << " = geompy." << theMethodName.ToCString() << "([";
+ pd << aShape << " = geompy.MakeFaceWires([";
// Shapes
it = theShapes.begin();
pd << ", " << (*it++);
}
}
- pd << "])";
+ pd << "], " << (int)isPlanarWanted << ")";
- SetErrorCode(OK);
+ // to provide warning
+ if (!isWarning) SetErrorCode(OK);
return aShape;
}
//=============================================================================
/*!
- * MakeGlueFaces
+ * MakeFaceFromSurface
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeGlueFaces
- (Handle(GEOM_Object) theShape,
- const Standard_Real theTolerance,
- const Standard_Boolean doKeepNonSolids)
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeFaceFromSurface
+ (Handle(GEOM_Object) theFace,
+ Handle(GEOM_Object) theWire)
{
SetErrorCode(KO);
- if (theShape.IsNull()) return NULL;
+ //Add a new object
+ Handle(GEOM_Object) aShape = GetEngine()->AddObject(GEOM_FACE);
- //Add a new Glued object
- Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GetDocID(), GEOM_GLUED);
+ //Add a new function
+ Handle(GEOM_Function) aFunction =
+ aShape->AddFunction(GEOMImpl_ShapeDriver::GetID(), FACE_FROM_SURFACE);
- //Add a new Glue function
- Handle(GEOM_Function) aFunction;
- aFunction = aGlued->AddFunction(GEOMImpl_GlueDriver::GetID(), GLUE_FACES);
- if (aFunction.IsNull()) return NULL;
+ if (aFunction.IsNull()) {
+ return NULL;
+ }
//Check if the function is set correctly
- if (aFunction->GetDriverGUID() != GEOMImpl_GlueDriver::GetID()) return NULL;
+ if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) {
+ return NULL;
+ }
- GEOMImpl_IGlue aCI (aFunction);
+ GEOMImpl_IShapes aCI (aFunction);
+ Handle(TColStd_HSequenceOfTransient) aShapesSeq =
+ new TColStd_HSequenceOfTransient;
+ Handle(GEOM_Function) aRefFace = theFace->GetLastFunction();
+ Handle(GEOM_Function) aRefWire = theWire->GetLastFunction();
- Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
- if (aRefShape.IsNull()) return NULL;
+ if (aRefFace.IsNull()) {
+ SetErrorCode("NULL argument face for the face construction");
+ return NULL;
+ }
+
+ if (aRefWire.IsNull()) {
+ SetErrorCode("NULL argument wire for the face construction");
+ return NULL;
+ }
+
+ aShapesSeq->Append(aRefFace);
+ aShapesSeq->Append(aRefWire);
+
+ aCI.SetShapes(aShapesSeq);
+
+ //Compute the face
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return NULL;
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump (aFunction) << aShape
+ << " = geompy.MakeFaceFromSurface(" << theFace << ", " << theWire << ")";
+
+ SetErrorCode(OK);
+
+ return aShape;
+}
+
+//=============================================================================
+/*!
+ * MakeFaceWithConstraints
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeFaceWithConstraints
+ (std::list<Handle(GEOM_Object)> theConstraints)
+{
+ SetErrorCode(KO);
+
+ //Add a new object
+ Handle(GEOM_Object) aShape = GetEngine()->AddObject(GEOM_FILLING);
+
+ //Add a new function
+ Handle(GEOM_Function) aFunction =
+ aShape->AddFunction(GEOMImpl_FillingDriver::GetID(), FILLING_ON_CONSTRAINTS);
+ if (aFunction.IsNull()) return NULL;
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_FillingDriver::GetID()) return NULL;
+
+ GEOMImpl_IFilling aCI (aFunction);
+ Handle(TColStd_HSequenceOfTransient) aConstraints = new TColStd_HSequenceOfTransient;
+
+ // Shapes
+ std::list<Handle(GEOM_Object)>::iterator it = theConstraints.begin();
+ while (it != theConstraints.end()) {
+ Handle(GEOM_Object) anObject = (*it);
+ if ( anObject.IsNull() || anObject->GetValue().ShapeType() != TopAbs_EDGE ) {
+ SetErrorCode("NULL argument edge for the face construction");
+ return NULL;
+ }
+ Handle(GEOM_Function) aRefSh = anObject->GetLastFunction();
+ aConstraints->Append(aRefSh);
+ it++;
+ if ( it != theConstraints.end() ) {
+ Handle(GEOM_Object) aFace = (*it);
+ if ( aFace.IsNull() ) {
+ // null constraint face - it is a valid case
+ it++;
+ continue;
+ }
+ if ( aFace->GetValue().ShapeType() != TopAbs_FACE )
+ // constraint face can be omitted - it is a valid case
+ continue;
+ // Keep the old error code as IsSubShapeBelongsTo changes it.
+ TCollection_AsciiString anOldCode = GetErrorCode();
+
+ if ( IsSubShapeBelongsTo( anObject, 0, aFace, 0 ) ) {
+ // valid constraint
+ SetErrorCode(anOldCode);
+ aRefSh = aFace->GetLastFunction();
+ aConstraints->Append(aRefSh);
+ it++;
+ }
+ else {
+ // bad constraint
+ SetErrorCode("Face is NULL or not connected to the Edge");
+ return NULL;
+ }
+ }
+ }
+ aCI.SetShapes( aConstraints );
+
+ //Compute the shape
+ Standard_Boolean isWarning = Standard_False;
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ // to provide warning
+ if (!aFunction->GetValue().IsNull()) {
+ isWarning = Standard_True;
+ } else {
+ return NULL;
+ }
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump pd (aFunction);
+ pd << aShape << " = geompy.MakeFaceWithConstraints([";
+
+ // Constraints
+ it = theConstraints.begin();
+ if (it != theConstraints.end() ) {
+ pd << (*it++);
+ while (it != theConstraints.end()) {
+ Handle(GEOM_Object) anObject = (*it++);
+ if( !anObject.IsNull() )
+ pd << ", " << anObject;
+ }
+ }
+ pd << "])";
+
+ // to provide warning
+ if (!isWarning) SetErrorCode(OK);
+ return aShape;
+}
+
+//=============================================================================
+/*!
+ * MakeShell
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeShell
+ (std::list<Handle(GEOM_Object)> theShapes)
+{
+ return MakeShape(theShapes, GEOM_SHELL, SHELL_FACES, "MakeShell");
+}
+
+//=============================================================================
+/*!
+ * MakeSolidShells
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeSolidShells
+ (std::list<Handle(GEOM_Object)> theShapes)
+{
+ return MakeShape(theShapes, GEOM_SOLID, SOLID_SHELLS, "MakeSolid");
+}
+
+//=============================================================================
+/*!
+ * MakeCompound
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeCompound
+ (std::list<Handle(GEOM_Object)> theShapes)
+{
+ return MakeShape(theShapes, GEOM_COMPOUND, COMPOUND_SHAPES, "MakeCompound");
+}
+
+//=============================================================================
+/*!
+ * MakeShape
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeShape
+ (std::list<Handle(GEOM_Object)> theShapes,
+ const Standard_Integer theObjectType,
+ const Standard_Integer theFunctionType,
+ const TCollection_AsciiString& theMethodName)
+{
+ SetErrorCode(KO);
+
+ //Add a new object
+ Handle(GEOM_Object) aShape = GetEngine()->AddObject(theObjectType);
+
+ //Add a new function
+ Handle(GEOM_Function) aFunction =
+ aShape->AddFunction(GEOMImpl_ShapeDriver::GetID(), theFunctionType);
+ if (aFunction.IsNull()) return NULL;
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) return NULL;
+
+ GEOMImpl_IShapes aCI (aFunction);
+
+ Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient;
+
+ // Shapes
+ std::list<Handle(GEOM_Object)>::iterator it = theShapes.begin();
+ for (; it != theShapes.end(); it++) {
+ Handle(GEOM_Function) aRefSh = (*it)->GetLastFunction();
+ if (aRefSh.IsNull()) {
+ SetErrorCode("NULL argument shape for the shape construction");
+ return NULL;
+ }
+ aShapesSeq->Append(aRefSh);
+ }
+ aCI.SetShapes(aShapesSeq);
+
+ //Compute the shape
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return NULL;
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump pd (aFunction);
+ pd << aShape << " = geompy." << theMethodName.ToCString() << "([";
+
+ // Shapes
+ it = theShapes.begin();
+ if (it != theShapes.end()) {
+ pd << (*it++);
+ while (it != theShapes.end()) {
+ pd << ", " << (*it++);
+ }
+ }
+ pd << "])";
+
+ SetErrorCode(OK);
+ return aShape;
+}
+
+//=============================================================================
+/*!
+ * MakeSolidFromConnectedFaces
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeSolidFromConnectedFaces
+ (std::list<Handle(GEOM_Object)> theFacesOrShells,
+ const Standard_Boolean isIntersect)
+{
+ SetErrorCode(KO);
+
+ //Add a new object
+ Handle(GEOM_Object) aSolid = GetEngine()->AddObject(GEOM_SOLID);
+
+ //Add a new function
+ Handle(GEOM_Function) aFunction =
+ aSolid->AddFunction(GEOMImpl_ShapeDriver::GetID(), SOLID_FACES);
+ if (aFunction.IsNull()) return NULL;
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) return NULL;
+
+ GEOMImpl_IShapes aCI (aFunction);
+
+ Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient;
+
+ // Shapes
+ std::list<Handle(GEOM_Object)>::iterator it = theFacesOrShells.begin();
+ for (; it != theFacesOrShells.end(); it++) {
+ Handle(GEOM_Function) aRefSh = (*it)->GetLastFunction();
+ if (aRefSh.IsNull()) {
+ SetErrorCode("NULL argument shape for the shape construction");
+ return NULL;
+ }
+ aShapesSeq->Append(aRefSh);
+ }
+ aCI.SetShapes(aShapesSeq);
+ aCI.SetIsIntersect(isIntersect);
+
+ //Compute the shape
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return NULL;
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump pd (aFunction);
+ pd << aSolid << " = geompy.MakeSolidFromConnectedFaces([";
+
+ // Shapes
+ it = theFacesOrShells.begin();
+ if (it != theFacesOrShells.end()) {
+ pd << (*it++);
+ while (it != theFacesOrShells.end()) {
+ pd << ", " << (*it++);
+ }
+ }
+ pd << "]," << (isIntersect ? "True" : "False") << ")";
+
+ SetErrorCode(OK);
+ return aSolid;
+}
+
+//=============================================================================
+/*!
+ * MakeGlueFaces
+ */
+//=============================================================================
+Handle(GEOM_Object)
+GEOMImpl_IShapesOperations::MakeGlueFaces (std::list< Handle(GEOM_Object) >& theShapes,
+ const Standard_Real theTolerance,
+ const Standard_Boolean doKeepNonSolids)
+{
+ SetErrorCode(KO);
+
+ Handle(TColStd_HSequenceOfTransient) objects = GEOM_Object::GetLastFunctions( theShapes );
+ if ( objects.IsNull() || objects->IsEmpty() ) {
+ SetErrorCode("NULL argument shape");
+ return NULL;
+ }
+
+ //Add a new Glued object
+ Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GEOM_GLUED);
+
+ //Add a new Glue function
+ Handle(GEOM_Function) aFunction;
+ aFunction = aGlued->AddFunction(GEOMImpl_GlueDriver::GetID(), GLUE_FACES);
+ if (aFunction.IsNull()) return NULL;
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_GlueDriver::GetID()) return NULL;
- aCI.SetBase(aRefShape);
+ GEOMImpl_IGlue aCI (aFunction);
+
+ aCI.SetBase( objects );
aCI.SetTolerance(theTolerance);
aCI.SetKeepNonSolids(doKeepNonSolids);
//Compute the sub-shape value
Standard_Boolean isWarning = Standard_False;
try {
-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Shape driver failed to glue faces");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
// to provide warning
if (!aFunction->GetValue().IsNull()) {
isWarning = Standard_True;
//Make a Python command
GEOM::TPythonDump(aFunction) << aGlued << " = geompy.MakeGlueFaces("
- << theShape << ", " << theTolerance << ")";
+ << theShapes << ", " << theTolerance << ")";
// to provide warning
if (!isWarning) SetErrorCode(OK);
* GetGlueFaces
*/
//=============================================================================
+/*
Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetGlueFaces
(Handle(GEOM_Object) theShape,
const Standard_Real theTolerance)
}
//Make a Python command
- if(anAsciiList.Length()>0)
+ if( anAsciiList.Length() > 0 ) {
anAsciiList.Trunc(anAsciiList.Length() - 1);
- Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
- GEOM::TPythonDump pd (aFunction, /*append=*/true);
- pd << "[" << anAsciiList.ToCString();
- pd << "] = geompy.GetGlueFaces(" << theShape << ", " << theTolerance << ")";
+ Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
+ GEOM::TPythonDump pd (aFunction, true);
+ pd << "[" << anAsciiList.ToCString();
+ pd << "] = geompy.GetGlueFaces(" << theShape << ", " << theTolerance << ")";
+ }
SetErrorCode(OK);
return aSeq;
}
+*/
//=============================================================================
/*!
* MakeGlueFacesByList
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeGlueFacesByList
- (Handle(GEOM_Object) theShape,
- const Standard_Real theTolerance,
- std::list<Handle(GEOM_Object)> theFaces,
- const Standard_Boolean doKeepNonSolids)
+Handle(GEOM_Object)
+GEOMImpl_IShapesOperations::MakeGlueFacesByList(std::list< Handle(GEOM_Object) >& theShapes,
+ const Standard_Real theTolerance,
+ std::list<Handle(GEOM_Object)> & theFaces,
+ const Standard_Boolean doKeepNonSolids,
+ const Standard_Boolean doGlueAllEdges)
{
SetErrorCode(KO);
- if (theShape.IsNull()) return NULL;
+ Handle(TColStd_HSequenceOfTransient) objects = GEOM_Object::GetLastFunctions( theShapes );
+ if ( objects.IsNull() || objects->IsEmpty() ) {
+ SetErrorCode("NULL argument shape");
+ return NULL;
+ }
+ Handle(TColStd_HSequenceOfTransient) aFaces = GEOM_Object::GetLastFunctions( theFaces );
+ if ( aFaces.IsNull() ) {
+ SetErrorCode("NULL argument shape for the shape construction");
+ return NULL;
+ }
//Add a new Glued object
- Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GetDocID(), GEOM_GLUED);
+ Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GEOM_GLUED);
//Add a new Glue function
Handle(GEOM_Function) aFunction;
GEOMImpl_IGlue aCI (aFunction);
- Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
- if (aRefShape.IsNull()) return NULL;
-
- aCI.SetBase(aRefShape);
+ aCI.SetBase( objects );
aCI.SetTolerance(theTolerance);
aCI.SetKeepNonSolids(doKeepNonSolids);
-
- Handle(TColStd_HSequenceOfTransient) aFaces = new TColStd_HSequenceOfTransient;
- std::list<Handle(GEOM_Object)>::iterator it = theFaces.begin();
- for (; it != theFaces.end(); it++) {
- Handle(GEOM_Function) aRefSh = (*it)->GetLastFunction();
- if (aRefSh.IsNull()) {
- SetErrorCode("NULL argument shape for the shape construction");
- return NULL;
- }
- aFaces->Append(aRefSh);
- }
+ aCI.SetGlueAllEdges(doGlueAllEdges);
aCI.SetFaces(aFaces);
//Compute the sub-shape value
Standard_Boolean isWarning = Standard_False;
try {
-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Shape driver failed to glue faces");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
// to provide warning
if (!aFunction->GetValue().IsNull()) {
isWarning = Standard_True;
GEOM::TPythonDump pd(aFunction);
pd << aGlued << " = geompy.MakeGlueFacesByList("
- << theShape << ", " << theTolerance << ", [";
- // Faces
- it = theFaces.begin();
- if (it != theFaces.end()) {
- pd << (*it++);
- while (it != theFaces.end()) {
- pd << ", " << (*it++);
+ << theShapes << ", " << theTolerance << ", " << theFaces << ", "
+ << (bool)doKeepNonSolids << ", " << (bool)doGlueAllEdges << ")";
+
+ // to provide warning
+ if (!isWarning) SetErrorCode(OK);
+ return aGlued;
+}
+
+//=============================================================================
+/*!
+ * MakeGlueEdges
+ */
+//=============================================================================
+Handle(GEOM_Object)
+GEOMImpl_IShapesOperations::MakeGlueEdges (std::list< Handle(GEOM_Object) >& theShapes,
+ const Standard_Real theTolerance)
+{
+ SetErrorCode(KO);
+
+ Handle(TColStd_HSequenceOfTransient) objects = GEOM_Object::GetLastFunctions( theShapes );
+ if ( objects.IsNull() || objects->IsEmpty() ) {
+ SetErrorCode("NULL argument shape");
+ return NULL;
+ }
+
+ //Add a new Glued object
+ Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GEOM_GLUED);
+
+ //Add a new Glue function
+ Handle(GEOM_Function) aFunction;
+ aFunction = aGlued->AddFunction(GEOMImpl_GlueDriver::GetID(), GLUE_EDGES);
+ if (aFunction.IsNull()) return NULL;
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_GlueDriver::GetID()) return NULL;
+
+ GEOMImpl_IGlue aCI (aFunction);
+
+ aCI.SetBase( objects );
+ aCI.SetTolerance(theTolerance);
+ aCI.SetKeepNonSolids(true);
+
+ //Compute the sub-shape value
+ Standard_Boolean isWarning = Standard_False;
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed to glue edges");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ // to provide warning
+ if (!aFunction->GetValue().IsNull()) {
+ isWarning = Standard_True;
+ } else {
+ return NULL;
+ }
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump(aFunction) << aGlued << " = geompy.MakeGlueEdges("
+ << theShapes << ", " << theTolerance << ")";
+
+ // to provide warning
+ if (!isWarning) SetErrorCode(OK);
+ return aGlued;
+}
+
+//=============================================================================
+/*!
+ * GetGlueShapes
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfTransient)
+GEOMImpl_IShapesOperations::GetGlueShapes (std::list< Handle(GEOM_Object) >& theShapes,
+ const Standard_Real theTolerance,
+ const TopAbs_ShapeEnum theType)
+{
+ SetErrorCode(KO);
+
+ TopoDS_Shape aShape;
+ TopTools_SequenceOfShape shapes;
+ std::list< Handle(GEOM_Object) >::iterator s = theShapes.begin();
+ Handle(GEOM_BaseObject) lastCreatedGO;
+ for ( ; s != theShapes.end(); ++s )
+ {
+ Handle(GEOM_Object) go = *s;
+ if ( go.IsNull() ) return NULL;
+ aShape = go->GetValue();
+ if ( aShape.IsNull() ) return NULL;
+ shapes.Append( aShape );
+ lastCreatedGO = GEOM::GetCreatedLast( lastCreatedGO, go );
+ }
+ if ( shapes.Length() > 1 )
+ {
+ TopoDS_Compound compound;
+ BRep_Builder builder;
+ builder.MakeCompound( compound );
+ for ( int i = 1; i <= shapes.Length(); ++i )
+ builder.Add( compound, shapes( i ) );
+
+ aShape = compound;
+ }
+
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ GEOMAlgo_GlueDetector aGluer;
+ aGluer.SetArgument(aShape);
+ aGluer.SetTolerance(theTolerance);
+ aGluer.Perform();
+ Standard_Integer iErr = aGluer.ErrorStatus();
+ if (iErr) return NULL;
+
+ std::vector< TopTools_IndexedMapOfShape* > anIndices( shapes.Length(), NULL );
+ Handle(TColStd_HArray1OfInteger) anArray;
+ Handle(GEOM_Object) anObj;
+
+ TopTools_ListOfShape listOnePerSet;
+
+ const TopTools_DataMapOfShapeListOfShape& aImages = aGluer.Images();
+ TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS (aImages);
+ for (int index = 1; aItDMSLS.More(); aItDMSLS.Next(), ++index) {
+ // some key shape
+ //const TopoDS_Shape& aSkey = aItDMSLS.Key();
+
+ // list of shapes of the argument that can be glued
+ const TopTools_ListOfShape& aLSD = aItDMSLS.Value();
+
+ //listShape.Append(aLSD.First());
+ TopoDS_Shape aValue = aLSD.First();
+
+ if (aValue.ShapeType() == theType) {
+ listOnePerSet.Append(aValue);
+ }
+ }
+
+ // for stable order of returned entities
+ GEOMUtils::SortShapes(listOnePerSet, Standard_False);
+
+ TopTools_ListIteratorOfListOfShape aListIt (listOnePerSet);
+ for (; aListIt.More(); aListIt.Next())
+ {
+ TopoDS_Shape aValue = aListIt.Value();
+ // find a shape to add aValue as a sub-shape
+ anObj.Nullify();
+ s = theShapes.begin();
+ for ( int i = 0; i < shapes.Length(); ++i, ++s )
+ {
+ Handle(GEOM_Object) object = *s;
+ if ( !anIndices[i] ) {
+ anIndices[i] = new TopTools_IndexedMapOfShape;
+ TopExp::MapShapes( object->GetValue(), *anIndices[i]);
+ }
+ if (int index = anIndices[i]->FindIndex( aValue )) {
+ anArray = new TColStd_HArray1OfInteger(1,1);
+ anArray->SetValue(1, index);
+ anObj = GetEngine()->AddSubShape( object, anArray);
+ break;
+ }
}
+ if (!anObj.IsNull())
+ aSeq->Append(anObj);
+ }
+ for ( size_t i = 0 ; i < anIndices.size(); ++i )
+ delete anIndices[i];
+
+ // Make a Python command
+ if ( aSeq->Length() > 0)
+ {
+ Handle(GEOM_Function) aFunction = lastCreatedGO->GetLastFunction();
+ GEOM::TPythonDump pd (aFunction, /*append=*/true);
+ pd << aSeq
+ << " = geompy." << (theType == TopAbs_FACE ? "GetGlueFaces" : "GetGlueEdges" )
+ << "( " << theShapes << ", " << theTolerance << ")";
+ }
+
+ SetErrorCode(OK);
+
+ return aSeq;
+}
+
+//=============================================================================
+/*!
+ * MakeGlueEdgesByList
+ */
+//=============================================================================
+Handle(GEOM_Object)
+GEOMImpl_IShapesOperations::MakeGlueEdgesByList (std::list< Handle(GEOM_Object) >& theShapes,
+ const Standard_Real theTolerance,
+ std::list<Handle(GEOM_Object)>& theEdges)
+{
+ SetErrorCode(KO);
+
+ Handle(TColStd_HSequenceOfTransient) objects = GEOM_Object::GetLastFunctions( theShapes );
+ if ( objects.IsNull() || objects->IsEmpty() ) {
+ SetErrorCode("NULL argument shape");
+ return NULL;
+ }
+ Handle(TColStd_HSequenceOfTransient) anEdges = GEOM_Object::GetLastFunctions( theEdges );
+ if ( anEdges.IsNull() ) {
+ SetErrorCode("NULL argument shape for the shape construction");
+ return NULL;
+ }
+ //Add a new Glued object
+ Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GEOM_GLUED);
+
+ //Add a new Glue function
+ Handle(GEOM_Function) aFunction;
+ aFunction = aGlued->AddFunction(GEOMImpl_GlueDriver::GetID(), GLUE_EDGES_BY_LIST);
+ if (aFunction.IsNull()) return NULL;
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_GlueDriver::GetID()) return NULL;
+
+ GEOMImpl_IGlue aCI (aFunction);
+
+ aCI.SetBase( objects );
+ aCI.SetTolerance(theTolerance);
+ aCI.SetKeepNonSolids(true);
+ aCI.SetFaces(anEdges);
+
+ //Compute the sub-shape value
+ Standard_Boolean isWarning = Standard_False;
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed to glue edges");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ // to provide warning
+ if (!aFunction->GetValue().IsNull()) {
+ isWarning = Standard_True;
+ } else {
+ return NULL;
+ }
+ }
+
+ //Make a Python command
+
+ GEOM::TPythonDump pd (aFunction);
+ pd << aGlued << " = geompy.MakeGlueEdgesByList("
+ << theShapes << ", " << theTolerance << ", " << theEdges << " )";
+
+ // to provide warning
+ if (!isWarning) SetErrorCode(OK);
+ return aGlued;
+}
+
+//=============================================================================
+/*!
+ * GetExistingSubObjects
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfTransient)
+GEOMImpl_IShapesOperations::GetExistingSubObjects(Handle(GEOM_Object) theShape,
+ const Standard_Boolean theGroupsOnly)
+{
+ // note: this method does not return fields
+
+ Standard_Integer types = theGroupsOnly ? Groups : Groups|SubShapes;
+ Handle(TColStd_HSequenceOfTransient) results = GetExistingSubObjects(theShape, types);
+
+ Handle(GEOM_BaseObject) lastCreatedGO = GEOM::GetCreatedLast(results);
+ lastCreatedGO = GEOM::GetCreatedLast(lastCreatedGO, theShape);
+
+ if (results->Length() > 0) {
+ // Make a Python command
+ GEOM::TPythonDump pd (lastCreatedGO->GetLastFunction(), /*append=*/true);
+ pd << "[";
+ Standard_Integer i, aLen = results->Length();
+ for (i = 1; i <= aLen; i++)
+ {
+ Handle(GEOM_BaseObject) obj = Handle(GEOM_BaseObject)::DownCast(results->Value(i));
+ pd << obj << ((i < aLen) ? ", " : "");
+ }
+ pd << "] = geompy.GetExistingSubObjects(";
+ pd << theShape << ", " << (bool)theGroupsOnly << ")";
+ }
+
+ return results;
+}
+
+Handle(TColStd_HSequenceOfTransient)
+GEOMImpl_IShapesOperations::GetExistingSubObjects(Handle(GEOM_Object) theShape,
+ const Standard_Integer theTypes)
+{
+ SetErrorCode(KO);
+
+ if (theShape.IsNull()) return NULL;
+
+ Handle(GEOM_Function) aMainShape = theShape->GetLastFunction();
+ if (aMainShape.IsNull()) return NULL;
+
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+ SetErrorCode(NOT_FOUND_ANY);
+
+ if (!aMainShape->HasSubShapeReferences()) return aSeq;
+ const TDataStd_ListOfExtendedString& aListEntries = aMainShape->GetSubShapeReferences();
+ if (aListEntries.IsEmpty()) return aSeq;
+
+ SetErrorCode(KO);
+
+ TDataStd_ListIteratorOfListOfExtendedString anIt (aListEntries);
+ for (; anIt.More(); anIt.Next()) {
+ TCollection_ExtendedString anEntry = anIt.Value();
+ Standard_Integer aStrLen = anEntry.LengthOfCString();
+ char* anEntryStr = new char[aStrLen+1];
+ anEntry.ToUTF8CString(anEntryStr);
+ Handle(GEOM_BaseObject) anObj = GetEngine()->GetObject(anEntryStr, false);
+ if (!anObj.IsNull() ) {
+ bool isGroup = anObj->IsKind(STANDARD_TYPE(GEOM_Object)) && anObj->GetType() == GEOM_GROUP;
+ bool isSubShape = anObj->IsKind(STANDARD_TYPE(GEOM_Object)) && anObj->GetType() != GEOM_GROUP;
+ bool isField = anObj->IsKind(STANDARD_TYPE(GEOM_Field));
+ if ((theTypes & Groups && isGroup ) ||
+ (theTypes & SubShapes && isSubShape ) ||
+ (theTypes & Fields && isField ))
+ aSeq->Append(anObj);
+ }
+ delete [] anEntryStr;
+ }
+
+ if (aSeq->Length() == 0) {
+ SetErrorCode(NOT_FOUND_ANY);
+ return aSeq;
}
- pd << "])";
- // to provide warning
- if (!isWarning) SetErrorCode(OK);
- return aGlued;
+ SetErrorCode(OK);
+
+ return aSeq;
}
//=============================================================================
Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::MakeExplode
(Handle(GEOM_Object) theShape,
const Standard_Integer theShapeType,
- const Standard_Boolean isSorted)
+ const Standard_Boolean isSorted,
+ const ExplodeType theExplodeType)
{
SetErrorCode(KO);
TopTools_ListOfShape listShape;
if (aShape.ShapeType() == TopAbs_COMPOUND &&
- (TopAbs_ShapeEnum(theShapeType) == TopAbs_SHAPE ||
- TopAbs_ShapeEnum(theShapeType) == TopAbs_COMPSOLID ||
- TopAbs_ShapeEnum(theShapeType) == TopAbs_COMPOUND)) {
+ (theShapeType == TopAbs_SHAPE || theShapeType == TopAbs_FLAT || theShapeType == TopAbs_COMPOUND))
+ {
TopoDS_Iterator It (aShape, Standard_True, Standard_True);
for (; It.More(); It.Next()) {
- if (mapShape.Add(It.Value())) {
- if (TopAbs_ShapeEnum(theShapeType) == TopAbs_SHAPE ||
- TopAbs_ShapeEnum(theShapeType) == It.Value().ShapeType()) {
- listShape.Append(It.Value());
+ TopoDS_Shape SS = It.Value();
+ if (mapShape.Add(SS)) {
+ if (theShapeType == TopAbs_FLAT) {
+ AddFlatSubShapes(SS, listShape, mapShape);
+ }
+ else if (theShapeType == TopAbs_SHAPE || theShapeType == SS.ShapeType()) {
+ listShape.Append(SS);
}
+ // VSR: for EXPLODE_NEW_INCLUDE_MAIN and EXPLODE_OLD_INCLUDE_MAIN:
+ // it seems it is necessary to add top-level shape if theShapeType == TopAbs_COMPOUND
}
}
- } else {
+ }
+ else if (theExplodeType != EXPLODE_NEW_EXCLUDE_MAIN || aShape.ShapeType() != theShapeType) // issue 0021079
+ {
TopExp_Explorer exp (aShape, TopAbs_ShapeEnum(theShapeType));
for (; exp.More(); exp.Next())
if (mapShape.Add(exp.Current()))
- listShape.Append(exp.Current());
+ listShape.Append(exp.Current());
}
- if (listShape.IsEmpty()) {
+ if (listShape.IsEmpty()){
//SetErrorCode("The given shape has no sub-shapes of the requested type");
SetErrorCode(NOT_FOUND_ANY); // NPAL18017
return aSeq;
}
- if (isSorted)
- SortShapes(listShape);
+ if (isSorted) {
+ bool isOldSorting = false;
+ if (theExplodeType == EXPLODE_OLD_INCLUDE_MAIN)
+ isOldSorting = true;
+ GEOMUtils::SortShapes(listShape, isOldSorting);
+ }
TopTools_IndexedMapOfShape anIndices;
TopExp::MapShapes(aShape, anIndices);
//anObj = GetEngine()->AddSubShape(theShape, anArray);
{
- anObj = GetEngine()->AddObject(GetDocID(), GEOM_SUBSHAPE);
+ anObj = GetEngine()->AddObject(GEOM_SUBSHAPE);
Handle(GEOM_Function) aFunction = anObj->AddFunction(GEOM_Object::GetSubShapeID(), 1);
if (aFunction.IsNull()) return aSeq;
// because GEOM_SubShapeDriver will build TopTools_IndexedMapOfShape
// on the main shape for each being calculated sub-shape separately.
aFunction->SetValue(aValue);
- }
+ // Put this subshape in the list of sub-shapes of theMainShape
+ aMainShape->AddSubShapeReference(aFunction);
+ }
if (!anObj.IsNull()) {
- aSeq->Append(anObj);
+ aSeq->Append(anObj);
- // for python command
- TDF_Tool::Entry(anObj->GetEntry(), anEntry);
- anAsciiList += anEntry;
- anAsciiList += ",";
- }
- }
+ // for python command
+ TDF_Tool::Entry(anObj->GetEntry(), anEntry);
+ anAsciiList += anEntry;
+ anAsciiList += ",";
+ }
+ }
//Make a Python command
anAsciiList.Trunc(anAsciiList.Length() - 1);
GEOM::TPythonDump pd (aMainShape, /*append=*/true);
- pd << "[" << anAsciiList.ToCString();
- pd << "] = geompy.SubShapeAll" << (isSorted ? "Sorted(" : "(");
- pd << theShape << ", " << TopAbs_ShapeEnum(theShapeType) << ")";
-
+ pd << "[" << anAsciiList.ToCString() << "] = geompy.";
+ switch (theExplodeType) {
+ case EXPLODE_NEW_EXCLUDE_MAIN:
+ pd << "ExtractShapes(" << theShape << ", "
+ << TopAbs_ShapeEnum(theShapeType) << ", " << (isSorted ? "True" : "False") << ")";
+ break;
+ case EXPLODE_NEW_INCLUDE_MAIN:
+ pd << "SubShapeAll" << (isSorted ? "SortedCentres(" : "(")
+ << theShape << ", " << TopAbs_ShapeEnum(theShapeType) << ")";
+ break;
+ case EXPLODE_OLD_INCLUDE_MAIN:
+ pd << "SubShapeAll" << (isSorted ? "Sorted(" : "(")
+ << theShape << ", " << TopAbs_ShapeEnum(theShapeType) << ")";
+ break;
+ default: ;
+ }
SetErrorCode(OK);
return aSeq;
Handle(TColStd_HSequenceOfInteger) GEOMImpl_IShapesOperations::SubShapeAllIDs
(Handle(GEOM_Object) theShape,
const Standard_Integer theShapeType,
- const Standard_Boolean isSorted)
+ const Standard_Boolean isSorted,
+ const ExplodeType theExplodeType)
{
SetErrorCode(KO);
TopTools_ListOfShape listShape;
if (aShape.ShapeType() == TopAbs_COMPOUND &&
- (TopAbs_ShapeEnum(theShapeType) == TopAbs_SHAPE ||
- TopAbs_ShapeEnum(theShapeType) == TopAbs_COMPSOLID ||
- TopAbs_ShapeEnum(theShapeType) == TopAbs_COMPOUND)) {
+ (theShapeType == TopAbs_SHAPE || theShapeType == TopAbs_FLAT || theShapeType == TopAbs_COMPOUND))
+ {
TopoDS_Iterator It (aShape, Standard_True, Standard_True);
for (; It.More(); It.Next()) {
- if (mapShape.Add(It.Value())) {
- if (TopAbs_ShapeEnum(theShapeType) == TopAbs_SHAPE ||
- TopAbs_ShapeEnum(theShapeType) == It.Value().ShapeType()) {
- listShape.Append(It.Value());
+ TopoDS_Shape SS = It.Value();
+ if (mapShape.Add(SS)) {
+ if (theShapeType == TopAbs_FLAT) {
+ AddFlatSubShapes(SS, listShape, mapShape);
+ }
+ else if (theShapeType == TopAbs_SHAPE || theShapeType == SS.ShapeType()) {
+ listShape.Append(SS);
}
}
}
- } else {
+ }
+ else if (theExplodeType != EXPLODE_NEW_EXCLUDE_MAIN || aShape.ShapeType() != theShapeType) // issue 0021079
+ {
TopExp_Explorer exp (aShape, TopAbs_ShapeEnum(theShapeType));
for (; exp.More(); exp.Next())
if (mapShape.Add(exp.Current()))
- listShape.Append(exp.Current());
+ listShape.Append(exp.Current());
}
if (listShape.IsEmpty()) {
return aSeq;
}
- if (isSorted)
- SortShapes(listShape);
+ if (isSorted) {
+ bool isOldSorting = false;
+ if (theExplodeType == EXPLODE_OLD_INCLUDE_MAIN)
+ isOldSorting = true;
+ GEOMUtils::SortShapes(listShape, isOldSorting);
+ }
TopTools_IndexedMapOfShape anIndices;
TopExp::MapShapes(aShape, anIndices);
Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
//Make a Python command
GEOM::TPythonDump pd (aFunction, /*append=*/true);
pd << "listSubShapeIDs = geompy.SubShapeAll";
- pd << (isSorted ? "SortedIDs(" : "IDs(");
- pd << theShape << ", " << TopAbs_ShapeEnum(theShapeType) << ")";
+ switch (theExplodeType) {
+ case EXPLODE_NEW_EXCLUDE_MAIN:
+ break;
+ case EXPLODE_NEW_INCLUDE_MAIN:
+ pd << (isSorted ? "SortedCentresIDs(" : "IDs(")
+ << theShape << ", " << TopAbs_ShapeEnum(theShapeType) << ")";
+ break;
+ case EXPLODE_OLD_INCLUDE_MAIN:
+ pd << (isSorted ? "SortedIDs(" : "IDs(")
+ << theShape << ", " << TopAbs_ShapeEnum(theShapeType) << ")";
+ break;
+ default: ;
+ }
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
return anObj;
}
+//=============================================================================
+/*!
+ * MakeSubShapes
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::MakeSubShapes
+ (Handle(GEOM_Object) theMainShape,
+ Handle(TColStd_HArray1OfInteger) theIndices)
+{
+ SetErrorCode(KO);
+
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ if (!theIndices->Length()) {
+ SetErrorCode(NOT_FOUND_ANY);
+ return aSeq;
+ }
+
+ if (theMainShape.IsNull()) return NULL;
+ TopoDS_Shape aShape = theMainShape->GetValue();
+ if (aShape.IsNull()) return NULL;
+
+ Handle(GEOM_Function) aMainShape = theMainShape->GetLastFunction();
+
+ TopTools_IndexedMapOfShape anIndices;
+ TopExp::MapShapes(aShape, anIndices);
+
+ Handle(TColStd_HArray1OfInteger) anArray;
+ Handle(GEOM_Object) anObj;
+
+ TCollection_AsciiString anAsciiList, anEntry;
+ Standard_Integer i, low = theIndices->Lower(), up = theIndices->Upper();
+ for (i = low; i <= up; i++) {
+ int id = theIndices->Value(i);
+ if (1 <= id && id <= anIndices.Extent()) {
+ TopoDS_Shape aValue = anIndices.FindKey(id);
+ anArray = new TColStd_HArray1OfInteger(1,1);
+ anArray->SetValue(1, id);
+
+ anObj = GetEngine()->AddObject(GEOM_SUBSHAPE);
+ if (!anObj.IsNull()) {
+ Handle(GEOM_Function) aFunction = anObj->AddFunction(GEOM_Object::GetSubShapeID(), 1);
+ if (aFunction.IsNull()) return aSeq;
+
+ GEOM_ISubShape aSSI (aFunction);
+ aSSI.SetMainShape(aMainShape);
+ aSSI.SetIndices(anArray);
+
+ // Set function value directly, as we know it.
+ // Usage of Solver here would lead to significant loss of time,
+ // because GEOM_SubShapeDriver will build TopTools_IndexedMapOfShape
+ // on the main shape for each being calculated sub-shape separately.
+ aFunction->SetValue(aValue);
+
+ // Put this sub-shape in the list of sub-shapes of theMainShape
+ aMainShape->AddSubShapeReference(aFunction);
+
+ aSeq->Append(anObj);
+
+ // for python command
+ TDF_Tool::Entry(anObj->GetEntry(), anEntry);
+ anAsciiList += anEntry;
+ anAsciiList += ",";
+ }
+ }
+ }
+
+ //Make a Python command
+ anAsciiList.Trunc(anAsciiList.Length() - 1);
+
+ GEOM::TPythonDump pd (aMainShape, /*append=*/true);
+ pd << "[" << anAsciiList.ToCString() << "] = geompy.SubShapes("
+ << theMainShape << ", [" ;
+ for (i = low; i <= up - 1; i++) {
+ pd << theIndices->Value(i) << ", ";
+ }
+ pd << theIndices->Value(up) << "])";
+
+ SetErrorCode(OK);
+
+ return aSeq;
+}
+
//=============================================================================
/*!
* GetSubShapeIndex
TopTools_IndexedMapOfShape anIndices;
TopExp::MapShapes(aMainShape, anIndices);
- if (anIndices.Contains(aSubShape)) {
+// if (anIndices.Contains(aSubShape)) {
+// SetErrorCode(OK);
+// return anIndices.FindIndex(aSubShape);
+// }
+ int id = anIndices.FindIndex(aSubShape);
+ if (id > 0)
+ {
SetErrorCode(OK);
- return anIndices.FindIndex(aSubShape);
+ return id;
}
-
return -1;
}
+
+
+//=============================================================================
+/*!
+ * GetSubShapeIndices
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfInteger) GEOMImpl_IShapesOperations::GetSubShapesIndices (Handle(GEOM_Object) theMainShape,
+ std::list<Handle(GEOM_Object)> theSubShapes)
+{
+ MESSAGE("GEOMImpl_IShapesOperations::GetSubShapesIndices")
+ SetErrorCode(KO);
+
+ Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger;
+
+ TopoDS_Shape aMainShape = theMainShape->GetValue();
+ if (aMainShape.IsNull())
+ {
+ MESSAGE("NULL main shape")
+ return NULL;
+ }
+
+ TopTools_IndexedMapOfShape anIndices;
+ TopExp::MapShapes(aMainShape, anIndices);
+
+ std::list<Handle(GEOM_Object)>::iterator it;
+ for (it=theSubShapes.begin(); it != theSubShapes.end(); ++it)
+ {
+ TopoDS_Shape aSubShape = (*it)->GetValue();
+ if (aSubShape.IsNull())
+ {
+ MESSAGE("NULL subshape")
+ return NULL;
+ }
+ int id = anIndices.FindIndex(aSubShape);
+ aSeq->Append(id);
+ }
+
+ SetErrorCode(OK);
+ return aSeq;
+}
+
+
//=============================================================================
/*!
* GetTopologyIndex
TopTools_ListIteratorOfListOfShape itC;
for (itC.Initialize(CL); itC.More(); itC.Next()) {
for (it.Initialize(itC.Value()); it.More(); it.Next()) {
- if (it.Value().ShapeType() == TopAbs_COMPOUND) {
- if (it.Value().IsSame(aSubShape))
- return index;
- else
- index++;
- CL.Append(it.Value());
- }
+ if (it.Value().ShapeType() == TopAbs_COMPOUND) {
+ if (it.Value().IsSame(aSubShape))
+ return index;
+ else
+ index++;
+ CL.Append(it.Value());
+ }
}
}
} else {
TopTools_MapOfShape M;
for (; anExp.More(); anExp.Next()) {
if (M.Add(anExp.Current())) {
- if (anExp.Current().IsSame(aSubShape))
- return index;
- index++;
+ if (anExp.Current().IsSame(aSubShape))
+ return index;
+ index++;
}
}
}
{
BRepAdaptor_Surface surf (TopoDS::Face(aShape));
if (surf.GetType() == GeomAbs_Plane)
- aTypeName = "Plane";
+ aTypeName = "Plane";
else if (surf.GetType() == GeomAbs_Cylinder)
- aTypeName = "Cylindrical Face";
+ aTypeName = "Cylindrical Face";
else if (surf.GetType() == GeomAbs_Sphere)
- aTypeName = "Spherical Face";
+ aTypeName = "Spherical Face";
else if (surf.GetType() == GeomAbs_Torus)
- aTypeName = "Toroidal Face";
+ aTypeName = "Toroidal Face";
else if (surf.GetType() == GeomAbs_Cone)
- aTypeName = "Conical Face";
+ aTypeName = "Conical Face";
else
- aTypeName = "GEOM::FACE";
+ aTypeName = "GEOM::FACE";
}
break;
case TopAbs_WIRE:
{
BRepAdaptor_Curve curv (TopoDS::Edge(aShape));
if (curv.GetType() == GeomAbs_Line) {
- if ((Abs(curv.FirstParameter()) >= 1E6) ||
+ if ((Abs(curv.FirstParameter()) >= 1E6) ||
(Abs(curv.LastParameter()) >= 1E6))
aTypeName = "Line";
- else
- aTypeName = "Edge";
+ else
+ aTypeName = "Edge";
} else if (curv.GetType() == GeomAbs_Circle) {
- if (curv.IsClosed())
+ if (curv.IsClosed())
aTypeName = "Circle";
- else
+ else
aTypeName = "Arc";
} else {
aTypeName = "Edge";
//=============================================================================
/*!
- * NumberOfFaces
+ * IsSubShapeBelongsTo
*/
//=============================================================================
-Standard_Integer GEOMImpl_IShapesOperations::NumberOfFaces (Handle(GEOM_Object) theShape)
+Standard_Boolean GEOMImpl_IShapesOperations::IsSubShapeBelongsTo( Handle(GEOM_Object) theSubObject,
+ const Standard_Integer theSubObjectIndex,
+ Handle(GEOM_Object) theObject,
+ const Standard_Integer theObjectIndex)
{
SetErrorCode(KO);
- Standard_Integer nb = 0;
+ if ( theObject.IsNull() || theSubObject.IsNull() )
+ return false;
- if (theShape.IsNull()) return -1;
- TopoDS_Shape aShape = theShape->GetValue();
- if (aShape.IsNull()) return -1;
+ TopoDS_Shape shape = theObject->GetValue();
+ TopoDS_Shape subShape = theSubObject->GetValue();
- TopTools_MapOfShape mapShape;
+ if ( shape.IsNull() || subShape.IsNull() )
+ return false;
+
+ TopTools_IndexedMapOfShape anIndices;
+ if ( theObjectIndex > 0 ) {
+ TopExp::MapShapes( shape, anIndices );
+ shape = anIndices.FindKey(theObjectIndex);
+ anIndices.Clear();
+ }
+ if ( theSubObjectIndex > 0 ) {
+ TopExp::MapShapes( subShape, anIndices );
+ subShape = anIndices.FindKey(theSubObjectIndex);
+ anIndices.Clear();
+ }
- TopExp_Explorer exp (aShape, TopAbs_FACE);
- for (; exp.More(); exp.Next())
- if (mapShape.Add(exp.Current()))
- nb++;
+ TopExp::MapShapes( shape, anIndices );
+
+ const Standard_Boolean isBelongTo = anIndices.Contains(subShape);
SetErrorCode(OK);
- return nb;
+
+ return isBelongTo;
}
//=============================================================================
/*!
- * NumberOfEdges
+ * NumberOfSubShapes
*/
//=============================================================================
-Standard_Integer GEOMImpl_IShapesOperations::NumberOfEdges (Handle(GEOM_Object) theShape)
+Standard_Integer GEOMImpl_IShapesOperations::NumberOfSubShapes
+ (Handle(GEOM_Object) theShape,
+ const Standard_Integer theShapeType)
{
SetErrorCode(KO);
-
- Standard_Integer nb = 0;
+ Standard_Integer nbShapes = 0;
if (theShape.IsNull()) return -1;
TopoDS_Shape aShape = theShape->GetValue();
if (aShape.IsNull()) return -1;
+ /*
TopTools_MapOfShape mapShape;
- TopExp_Explorer exp (aShape, TopAbs_EDGE);
- for (; exp.More(); exp.Next())
- if (mapShape.Add(exp.Current()))
- nb++;
+ if (aShape.ShapeType() == TopAbs_COMPOUND &&
+ (TopAbs_ShapeEnum(theShapeType) == TopAbs_SHAPE ||
+ TopAbs_ShapeEnum(theShapeType) == TopAbs_COMPSOLID ||
+ TopAbs_ShapeEnum(theShapeType) == TopAbs_COMPOUND)) {
+ TopoDS_Iterator It (aShape, Standard_True, Standard_True);
+ for (; It.More(); It.Next()) {
+ if (mapShape.Add(It.Value())) {
+ if (TopAbs_ShapeEnum(theShapeType) == TopAbs_SHAPE ||
+ TopAbs_ShapeEnum(theShapeType) == It.Value().ShapeType()) {
+ nbShapes++;
+ }
+ }
+ }
+ } else {
+ TopExp_Explorer exp (aShape, TopAbs_ShapeEnum(theShapeType));
+ for (; exp.More(); exp.Next())
+ if (mapShape.Add(exp.Current()))
+ nbShapes++;
+ }
+ */
+
+ try {
+ if (theShapeType == TopAbs_FLAT) {
+ TopTools_MapOfShape aMapOfShape;
+ TopTools_ListOfShape aListOfShape;
+ AddFlatSubShapes(aShape, aListOfShape, aMapOfShape);
+ nbShapes = aListOfShape.Extent();
+ }
+ else {
+ OCC_CATCH_SIGNALS;
+ int iType, nbTypes [TopAbs_SHAPE];
+ for (iType = 0; iType < TopAbs_SHAPE; ++iType)
+ nbTypes[iType] = 0;
+ nbTypes[aShape.ShapeType()]++;
+
+ TopTools_MapOfShape aMapOfShape;
+ aMapOfShape.Add(aShape);
+ TopTools_ListOfShape aListOfShape;
+ aListOfShape.Append(aShape);
+
+ TopTools_ListIteratorOfListOfShape itL (aListOfShape);
+ for (; itL.More(); itL.Next()) {
+ TopoDS_Iterator it (itL.Value());
+ for (; it.More(); it.Next()) {
+ TopoDS_Shape s = it.Value();
+ if (aMapOfShape.Add(s)) {
+ aListOfShape.Append(s);
+ nbTypes[s.ShapeType()]++;
+ }
+ }
+ }
+
+ if (TopAbs_ShapeEnum(theShapeType) == TopAbs_SHAPE)
+ nbShapes = aMapOfShape.Extent();
+ else
+ nbShapes = nbTypes[theShapeType];
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return -1;
+ }
SetErrorCode(OK);
- return nb;
+ return nbShapes;
}
//=============================================================================
if (theShape.IsNull()) return NULL;
+ /*
//Add a new reversed object
- Handle(GEOM_Object) aReversed = GetEngine()->AddObject(GetDocID(), theShape->GetType());
+ Handle(GEOM_Object) aReversed = GetEngine()->AddObject(theShape->GetType());
//Add a new Revese function
Handle(GEOM_Function) aFunction;
//Compute the sub-shape value
try {
-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Shape driver failed to reverse shape");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
<< " = geompy.ChangeOrientation(" << theShape << ")";
SetErrorCode(OK);
+ */
+
+ Handle(GEOM_Object) aReversed;
+
+ GEOM_Engine* anEngine = GetEngine();
+ //GEOMImpl_Gen* aGen = dynamic_cast<GEOMImpl_Gen*>(anEngine);
+ GEOMImpl_Gen* aGen = (GEOMImpl_Gen*)anEngine;
+
+ if (aGen) {
+ GEOMImpl_IHealingOperations* anIHealingOperations =
+ aGen->GetIHealingOperations();
+ aReversed = anIHealingOperations->ChangeOrientationCopy(theShape);
+ SetErrorCode(anIHealingOperations->GetErrorCode());
+ }
+
return aReversed;
}
//The explode doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
//Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listFreeFacesIDs = geompy.GetFreeFacesIDs(" << theShape << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
}
if (aSeq->IsEmpty()) {
- SetErrorCode("The given shapes have no shared sub-shapes of the requested type");
+ SetErrorCode(NOT_FOUND_ANY);
return aSeq;
}
return aSeq;
}
+//=======================================================================
+//function : GetSharedShapes
+//purpose :
+//
+// NOTE on the implementation
+//
+// 1) Resulting sub-shapes are published as a children of the 1st input shape
+// from theShapes list. Due to this reason only direct sub-shapes of the 1st
+// shape can be contained in the result of the operation (i.e. shares between
+// 2nd/3rd, etc couples cannot be retrieved.
+// 2) An exception from above case is when a single compound is specified as an
+// input. In this case we search shares between its top-level content, so we
+// are able to search shares between all possible couples of shapes.
+// 3) Parameter theMultiShare controls what types of shares to search:
+// - True: get sub-shapes that are shared between ALL input shapes;
+// - False: get shares between couples of input sub-shapes (see points 1 and 2).
+//
+// Thus, we have the following cases:
+// [1] theShapes = N shapes (N>1), theMultiShare = True
+// Result: sub-shapes that are shared by all theShapes
+// [2] theShapes = N shapes (N>1), theMultiShare = False
+// Result: sub-shapes of 1st shape from theShapes that are shared with any shape
+// from theShapes
+// [3] theShapes = 1 shape, theMultiShare = True
+// Result: sub-shapes that are shared by all top-level sub-objects of theShapes[0]
+// [4] theShapes = 1 shape, theMultiShare = False
+// Result: sub-shapes of all possible couples of all top-level sub-objects of
+// theShapes[0].
+//=======================================================================
+Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetSharedShapes
+ (std::list<Handle(GEOM_Object)> & theShapes,
+ const Standard_Integer theShapeType,
+ const bool theMultiShare)
+{
+ SetErrorCode(KO);
+
+ int aLen = theShapes.size();
+ if (aLen < 1) return NULL;
+
+ std::list<Handle(GEOM_Object)>::iterator it = theShapes.begin();
+
+ // main object is always first in the input list
+ // it is the object from which sub-shapes indices are taken
+ // and where results are published
+ Handle(GEOM_Object) aMainObj = *it;
+ Handle(GEOM_Function) aMainShape = aMainObj->GetLastFunction();
+
+ // collect all shapes from the input list (including first one) for processing
+ TopTools_SequenceOfShape shapeSeq;
+ for (; it != theShapes.end(); it++) {
+ Handle(GEOM_Function) aRefShape = (*it)->GetLastFunction();
+ if (aRefShape.IsNull()) {
+ SetErrorCode("NULL shape for GetSharedShapes");
+ return NULL;
+ }
+ TopoDS_Shape aShape = aRefShape->GetValue();
+ if (aShape.IsNull()) {
+ SetErrorCode("NULL shape for GetSharedShapes");
+ return NULL;
+ }
+ shapeSeq.Append( aShape );
+ }
+
+ // if only single shape is specified as input
+ // collect all ites top-level sub-shapes for processing
+ if ( shapeSeq.Length() == 1 )
+ {
+ TopoDS_Shape aShape = shapeSeq.First();
+ shapeSeq.Clear();
+ for ( TopoDS_Iterator it( aShape ); it.More(); it.Next() )
+ shapeSeq.Append( it.Value() );
+ }
+
+ // map all sub-shapes in a main shape to their indices
+ TopTools_IndexedMapOfShape anIndices;
+ TopExp::MapShapes(aMainShape->GetValue(), anIndices);
+ TopTools_MapOfShape mapShape;
+
+ // find shared shapes
+
+ // here we will collect all shares
+ TopTools_ListOfShape aShared;
+
+ // number of iterations
+ int nbIters = theMultiShare || theShapes.size() > 1 ? 1 : shapeSeq.Length()-1;
+ // numShares factor to search (i.e. by what nb of shapes each found sub-shape should be shared)
+ int nbShares = theMultiShare ? shapeSeq.Length()-1 : 1;
+
+ for ( int iter = 1; iter <= nbIters; iter++) {
+ for ( int ind = iter+1; ind <= shapeSeq.Length(); ind++) {
+ if ( ind-1+nbShares > shapeSeq.Length() ) break;
+ TopoDS_Compound aCurrSelection;
+ TopoDS_Shape aShape1 = shapeSeq.Value( iter );
+ TopTools_IndexedMapOfShape mapSelected;
+ TopExp::MapShapes(aShape1, TopAbs_ShapeEnum(theShapeType), mapSelected);
+ for ( int s = 0; s < nbShares; s++ ) {
+ BRep_Builder B;
+ TopoDS_Compound aCompound;
+ B.MakeCompound(aCompound);
+ const TopoDS_Shape& aShape2 = shapeSeq.Value( ind+s );
+ TopTools_MapOfShape mapShape2;
+ TopExp_Explorer exp (aShape2, TopAbs_ShapeEnum(theShapeType));
+ for (; exp.More(); exp.Next()) {
+ const TopoDS_Shape& aSS = exp.Current();
+ if (mapShape2.Add(aSS) && mapSelected.Contains(aSS)) {
+ B.Add(aCompound, aSS);
+ }
+ }
+ mapSelected.Clear();
+ aCurrSelection = aCompound;
+ TopExp::MapShapes(aCurrSelection, TopAbs_ShapeEnum(theShapeType), mapSelected);
+ }
+ TopoDS_Iterator itSel(aCurrSelection, Standard_True, Standard_True);
+ for (; itSel.More(); itSel.Next()) {
+ const TopoDS_Shape& aSS = itSel.Value();
+ if (mapShape.Add(aSS) )
+ aShared.Append(aSS);
+ }
+ }
+ }
+
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ if (aShared.IsEmpty()){
+ SetErrorCode(NOT_FOUND_ANY);
+ return aSeq;
+ }
+
+ // create GEOM_Object for each found shared shape (collected in aShared)
+ TCollection_AsciiString anAsciiList;
+ Handle(GEOM_Object) anObj;
+ TopTools_ListIteratorOfListOfShape itSub (aShared);
+ for (; itSub.More(); itSub.Next()) {
+ TopoDS_Shape aValue = itSub.Value();
+ Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
+ anArray->SetValue(1, anIndices.FindIndex(aValue));
+ anObj = GetEngine()->AddSubShape(aMainObj, anArray);
+ aSeq->Append(anObj);
+
+ // for python command
+ TCollection_AsciiString anEntry;
+ TDF_Tool::Entry(anObj->GetEntry(), anEntry);
+ anAsciiList += anEntry;
+ anAsciiList += ",";
+ }
+
+ // make a Python command
+ anAsciiList.Trunc(anAsciiList.Length() - 1);
+
+ GEOM::TPythonDump pd (anObj->GetLastFunction());
+ pd << "[" << anAsciiList.ToCString()
+ << "] = geompy.GetSharedShapesMulti(";
+
+ if ( aLen > 1 )
+ pd << "[";
+
+ it = theShapes.begin();
+ pd << (*it++);
+ while (it != theShapes.end()) {
+ pd << ", " << (*it++);
+ }
+ if ( aLen > 1 )
+ pd << "]";
+
+ pd << ", " << TopAbs_ShapeEnum(theShapeType) << ", " << theMultiShare << ")";
+
+ SetErrorCode(OK);
+ return aSeq;
+}
+
//=============================================================================
/*!
*
{
switch (theState) {
case GEOMAlgo_ST_IN:
- theDump << "geompy.GEOM.ST_IN";
+ theDump << "GEOM.ST_IN";
break;
case GEOMAlgo_ST_OUT:
- theDump << "geompy.GEOM.ST_OUT";
+ theDump << "GEOM.ST_OUT";
break;
case GEOMAlgo_ST_ON:
- theDump << "geompy.GEOM.ST_ON";
+ theDump << "GEOM.ST_ON";
break;
case GEOMAlgo_ST_ONIN:
- theDump << "geompy.GEOM.ST_ONIN";
+ theDump << "GEOM.ST_ONIN";
break;
case GEOMAlgo_ST_ONOUT:
- theDump << "geompy.GEOM.ST_ONOUT";
+ theDump << "GEOM.ST_ONOUT";
break;
default:
- theDump << "geompy.GEOM.ST_UNKNOWN";
+ theDump << "GEOM.ST_UNKNOWN";
break;
}
return theDump;
//=======================================================================
//function : getShapesOnBoxIDs
/*!
- * \brief Find IDs of subshapes complying with given status about surface
- * \param theBox - the box to check state of subshapes against
+ * \brief Find IDs of sub-shapes complying with given status about surface
+ * \param theBox - the box to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found subshapes
+ * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfInteger)
GEOMImpl_IShapesOperations::getShapesOnBoxIDs(const Handle(GEOM_Object)& theBox,
- const Handle(GEOM_Object)& theShape,
- const Standard_Integer theShapeType,
- GEOMAlgo_State theState)
+ const Handle(GEOM_Object)& theShape,
+ const Standard_Integer theShapeType,
+ GEOMAlgo_State theState)
{
Handle(TColStd_HSequenceOfInteger) aSeqOfIDs;
TopoDS_Shape aShape = theShape->GetValue();
// Check presence of triangulation, build if need
- if (!CheckTriangulation(aShape)) {
+ if (theShapeType != TopAbs_VERTEX && !GEOMUtils::CheckTriangulation(aShape)) {
SetErrorCode("Cannot build triangulation on the shape");
return aSeqOfIDs;
}
aFinder.SetState(theState);
aFinder.Perform();
- // Interprete results
+ // Interpret results
Standard_Integer iErr = aFinder.ErrorStatus();
- // the detailed description of error codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of error codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iErr) {
MESSAGE(" iErr : " << iErr);
TCollection_AsciiString aMsg (" iErr : ");
return aSeqOfIDs;
}
Standard_Integer iWrn = aFinder.WarningStatus();
- // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iWrn) {
MESSAGE(" *** iWrn : " << iWrn);
}
//=======================================================================
//function : GetShapesOnBoxIDs
/*!
- * \brief Find subshapes complying with given status about surface
- * \param theBox - the box to check state of subshapes against
+ * \brief Find sub-shapes complying with given status about surface
+ * \param theBox - the box to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found subshapes
+ * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfInteger)
GEOMImpl_IShapesOperations::GetShapesOnBoxIDs(const Handle(GEOM_Object)& theBox,
- const Handle(GEOM_Object)& theShape,
- const Standard_Integer theShapeType,
- GEOMAlgo_State theState)
+ const Handle(GEOM_Object)& theShape,
+ const Standard_Integer theShapeType,
+ GEOMAlgo_State theState)
{
- // Find subshapes ids
+ // Find sub-shapes ids
Handle(TColStd_HSequenceOfInteger) aSeqOfIDs =
getShapesOnBoxIDs (theBox, theShape, theShapeType, theState);
if ( aSeqOfIDs.IsNull() || aSeqOfIDs->Length() == 0 )
// The GetShapesOnBox() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theBox)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
- GEOM::TPythonDump(aFunction)
+ GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnBoxIDs = geompy.GetShapesOnBoxIDs("
<< theBox << ", "
<< theShape << ", "
<< TopAbs_ShapeEnum(theShapeType) << ", "
<< theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeqOfIDs;
//=======================================================================
//function : GetShapesOnBox
/*!
- * \brief Find subshapes complying with given status about surface
- * \param theBox - the box to check state of subshapes against
+ * \brief Find sub-shapes complying with given status about surface
+ * \param theBox - the box to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfTransient) - found subshapes
+ * \retval Handle(TColStd_HSequenceOfTransient) - found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfTransient)
GEOMImpl_IShapesOperations::GetShapesOnBox(const Handle(GEOM_Object)& theBox,
- const Handle(GEOM_Object)& theShape,
- const Standard_Integer theShapeType,
- GEOMAlgo_State theState)
+ const Handle(GEOM_Object)& theShape,
+ const Standard_Integer theShapeType,
+ GEOMAlgo_State theState)
{
- // Find subshapes ids
+ // Find sub-shapes ids
Handle(TColStd_HSequenceOfInteger) aSeqOfIDs =
getShapesOnBoxIDs (theBox, theShape, theShapeType, theState);
if ( aSeqOfIDs.IsNull() || aSeqOfIDs->Length() == 0 )
//=======================================================================
//function : getShapesOnShapeIDs
/*!
- * \brief Find IDs of subshapes complying with given status about surface
- * \param theCheckShape - the shape to check state of subshapes against
+ * \brief Find IDs of sub-shapes complying with given status about surface
+ * \param theCheckShape - the shape to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found subshapes
+ * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfInteger)
TopTools_ListOfShape res;
// Check presence of triangulation, build if need
- if (!CheckTriangulation(aShape)) {
+ if (theShapeType != TopAbs_VERTEX && !GEOMUtils::CheckTriangulation(aShape)) {
SetErrorCode("Cannot build triangulation on the shape");
return aSeqOfIDs;
}
+ // Compute classification tolerance.
+ TopTools_IndexedMapOfShape aMapVtx;
+ Standard_Real aTol = Precision::Confusion();
+
+ TopExp::MapShapes(aShape, TopAbs_VERTEX, aMapVtx);
+
+ Standard_Integer i;
+ Standard_Integer aNbVtx = aMapVtx.Extent();
+
+ for (i = 1; i <= aNbVtx; ++i) {
+ const TopoDS_Vertex aVtx = TopoDS::Vertex(aMapVtx.FindKey(i));
+ const Standard_Real aVtxTol = BRep_Tool::Tolerance(aVtx);
+
+ if (aTol < aVtxTol) {
+ aTol = aVtxTol;
+ }
+ }
+
+ // Bound the tolerance value.
+ if (aTol > 0.0001) {
+ aTol = 0.0001;
+ }
+
// Call algo
GEOMAlgo_FinderShapeOn2 aFinder;
- Standard_Real aTol = 0.0001; // default value
Handle(GEOMAlgo_ClsfSolid) aClsfSolid = new GEOMAlgo_ClsfSolid;
aClsfSolid->SetShape(aCheckShape);
aFinder.SetState(theState);
aFinder.Perform();
- // Interprete results
+ // Interpret results
Standard_Integer iErr = aFinder.ErrorStatus();
- // the detailed description of error codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of error codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iErr) {
- MESSAGE(" iErr : " << iErr);
- TCollection_AsciiString aMsg (" iErr : ");
- aMsg += TCollection_AsciiString(iErr);
- SetErrorCode(aMsg);
+ if (iErr == 41) {
+ SetErrorCode("theCheckShape must be a solid");
+ }
+ else {
+ MESSAGE(" iErr : " << iErr);
+ TCollection_AsciiString aMsg (" iErr : ");
+ aMsg += TCollection_AsciiString(iErr);
+ SetErrorCode(aMsg);
+ }
return aSeqOfIDs;
}
Standard_Integer iWrn = aFinder.WarningStatus();
- // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iWrn) {
MESSAGE(" *** iWrn : " << iWrn);
}
//=======================================================================
//function : GetShapesOnShapeIDs
/*!
- * \brief Find subshapes complying with given status about surface
- * \param theCheckShape - the shape to check state of subshapes against
+ * \brief Find sub-shapes complying with given status about surface
+ * \param theCheckShape - the shape to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found subshapes
+ * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfInteger)
Handle(GEOM_Function) aFunction =
GEOM::GetCreatedLast(theShape,theCheckShape)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
- GEOM::TPythonDump(aFunction)
- << "listShapesOnBoxIDs = geompy.GetShapesOnShapeIDs("
+ GEOM::TPythonDump(aFunction, /*append=*/true)
+ << "listShapesOnShapeIDs = geompy.GetShapesOnShapeIDs("
<< theCheckShape << ", "
<< theShape << ", "
<< TopAbs_ShapeEnum(theShapeType) << ", "
<< theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeqOfIDs;
//=======================================================================
//function : GetShapesOnShape
/*!
- * \brief Find subshapes complying with given status about surface
- * \param theCheckShape - the shape to check state of subshapes against
+ * \brief Find sub-shapes complying with given status about surface
+ * \param theCheckShape - the shape to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfTransient) - found subshapes
+ * \retval Handle(TColStd_HSequenceOfTransient) - found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfTransient)
}
//Add a new result object
- Handle(GEOM_Object) aRes = GetEngine()->AddObject(GetDocID(), GEOM_SHAPES_ON_SHAPE);
+ Handle(GEOM_Object) aRes = GetEngine()->AddObject(GEOM_SHAPES_ON_SHAPE);
Handle(GEOM_Function) aFunction =
aRes->AddFunction(GEOMImpl_ShapeDriver::GetID(), SHAPES_ON_SHAPE);
aFunction->SetValue(aCompound);
+ aSeq->Clear();
+ aSeq->Append( theCheckShape->GetLastFunction() );
+ aSeq->Append( theShape->GetLastFunction() );
+
+ GEOMImpl_IShapes aCI( aFunction );
+ aCI.SetShapes( aSeq );
+ aCI.SetSubShapeType( theShapeType );
+ aCI.SetTolerance( theState );
+
GEOM::TPythonDump(aFunction)
<< aRes << " = geompy.GetShapesOnShapeAsCompound("
<< theCheckShape << ", "
return aRes;
}
+//=============================================================================
+/*!
+ * GetSubShapeEdgeSorted
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfTransient)
+ GEOMImpl_IShapesOperations::GetSubShapeEdgeSorted
+ (const Handle(GEOM_Object) &theShape,
+ const Handle(GEOM_Object) &theStartPoint)
+{
+ // Get the sorted edges indices.
+ Handle(TColStd_HSequenceOfInteger) aSortedIDs =
+ getSubShapeEdgeSortedIDs(theShape, theStartPoint);
+
+ // Get object by indices.
+ TCollection_AsciiString anAsciiList;
+ Handle(TColStd_HSequenceOfTransient) aSeq =
+ getObjectsShapesOn(theShape, aSortedIDs, anAsciiList);
+
+ if (aSeq.IsNull() || aSeq->IsEmpty()) {
+ SetErrorCode("Empty sequence of edges");
+ return NULL;
+ }
+
+ // Make a Python command
+ Handle(GEOM_Object) anObj =
+ Handle(GEOM_Object)::DownCast(aSeq->Value(1));
+ Handle(GEOM_Function) aFunction = anObj->GetLastFunction();
+
+ GEOM::TPythonDump(aFunction)
+ << "[" << anAsciiList.ToCString() << "] = geompy.GetSubShapeEdgeSorted("
+ << theShape << ", " << theStartPoint << ")";
+
+ SetErrorCode(OK);
+
+ return aSeq;
+}
+
+//=============================================================================
+/*!
+ * GetSubShapesWithTolerance
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfTransient)
+ GEOMImpl_IShapesOperations::GetSubShapesWithTolerance
+ (const Handle(GEOM_Object) &theShape,
+ const Standard_Integer theShapeType,
+ const GEOMUtils::ComparisonCondition theCondition,
+ const Standard_Real theTolerance)
+{
+ if (theShape.IsNull()) {
+ SetErrorCode("NULL GEOM object");
+ return NULL;
+ }
+
+ TopoDS_Shape aShape = theShape->GetValue();
+
+ if (aShape.IsNull()) {
+ SetErrorCode("NULL Shape");
+ return NULL;
+ }
+
+ if (theShapeType != TopAbs_FACE && theShapeType != TopAbs_EDGE &&
+ theShapeType != TopAbs_VERTEX && aShape.ShapeType() >= theShapeType) {
+ SetErrorCode("Invalid shape type");
+ return NULL;
+ }
+
+ TopTools_IndexedMapOfShape anIndices;
+ TopTools_MapOfShape aMapFence;
+ TopExp_Explorer anExp(aShape,
+ (TopAbs_ShapeEnum) theShapeType);
+ Handle(TColStd_HSequenceOfInteger) anIDs = new TColStd_HSequenceOfInteger;
+
+ TopExp::MapShapes(aShape, anIndices);
+
+ for (; anExp.More(); anExp.Next()) {
+ const TopoDS_Shape &aSubShape = anExp.Current();
+
+ if (aMapFence.Add(aSubShape)) {
+ // Compute tolerance
+ Standard_Real aTolerance = -1.;
+
+ switch (aSubShape.ShapeType()) {
+ case TopAbs_FACE:
+ aTolerance = BRep_Tool::Tolerance(TopoDS::Face(aSubShape));
+ break;
+ case TopAbs_EDGE:
+ aTolerance = BRep_Tool::Tolerance(TopoDS::Edge(aSubShape));
+ break;
+ case TopAbs_VERTEX:
+ aTolerance = BRep_Tool::Tolerance(TopoDS::Vertex(aSubShape));
+ break;
+ default:
+ break;
+ }
+
+ if (aTolerance < 0.) {
+ continue;
+ }
+
+ // Compare the tolerance with reference value.
+ if (GEOMUtils::IsFitCondition (theCondition, aTolerance, theTolerance)) {
+ anIDs->Append(anIndices.FindIndex(aSubShape));
+ }
+ }
+ }
+
+ if (anIDs->IsEmpty()) {
+ SetErrorCode("Empty sequence of sub-shapes");
+ return NULL;
+ }
+
+ // Get objects by indices.
+ TCollection_AsciiString anAsciiList;
+ Handle(TColStd_HSequenceOfTransient) aSeq =
+ getObjectsShapesOn(theShape, anIDs, anAsciiList);
+
+ if (aSeq.IsNull() || aSeq->IsEmpty()) {
+ SetErrorCode("Empty sequence of edges");
+ return NULL;
+ }
+
+ // Make a Python command
+ Handle(GEOM_Object) anObj =
+ Handle(GEOM_Object)::DownCast(aSeq->Value(1));
+ Handle(GEOM_Function) aFunction = anObj->GetLastFunction();
+
+ GEOM::TPythonDump(aFunction)
+ << "[" << anAsciiList.ToCString() << "] = geompy.GetSubShapesWithTolerance("
+ << theShape << ", " << theShapeType << ", " << theCondition << ", "
+ << theTolerance << ")";
+
+ SetErrorCode(OK);
+
+ return aSeq;
+}
+
+//=============================================================================
+/*!
+ * MakeExtraction
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeExtraction
+ (const Handle(GEOM_Object) &theShape,
+ const Handle(TColStd_HArray1OfInteger) &theSubShapeIDs,
+ std::list<ExtractionStat> &theStats)
+{
+ SetErrorCode(KO);
+
+ if (theShape.IsNull()) {
+ return NULL;
+ }
+
+ //Add a new Result object
+ Handle(GEOM_Object) aResult =
+ GetEngine()->AddObject(GEOM_EXTRACTION);
+
+ //Add a new Extraction function
+ Handle(GEOM_Function) aFunction =
+ aResult->AddFunction(GEOMImpl_ShapeDriver::GetID(), EXTRACTION);
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) {
+ return NULL;
+ }
+
+ Handle(GEOM_Function) aShape = theShape->GetLastFunction();
+
+ if (aShape.IsNull()) {
+ return NULL;
+ }
+
+ GEOMImpl_IExtract aCI (aFunction);
+
+ aCI.SetShape(aShape);
+ aCI.SetSubShapeIDs(theSubShapeIDs);
+
+ //Compute the Edge value
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed");
+
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+
+ return NULL;
+ }
+
+ // Fill in statistics.
+ theStats.clear();
+
+ Handle(TColStd_HArray1OfInteger) aStatIDsArray[3] =
+ { aCI.GetRemovedIDs(), aCI.GetModifiedIDs(), aCI.GetAddedIDs() };
+ int i;
+ int j;
+
+ for (j = 0; j < 3; ++j) {
+ if (!aStatIDsArray[j].IsNull()) {
+ const int anUpperID = aStatIDsArray[j]->Upper();
+ ExtractionStat aStat;
+
+ for (i = aStatIDsArray[j]->Lower(); i <= anUpperID; ++i) {
+ aStat.indices.push_back(aStatIDsArray[j]->Value(i));
+ }
+
+ aStat.type = (ExtractionStatType) j;
+ theStats.push_back(aStat);
+ }
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump pd(aFunction);
+
+ pd << aResult << " = geompy.MakeExtraction(" << theShape << ", [";
+
+ if (!theSubShapeIDs.IsNull()) {
+ const int aNbIDs = theSubShapeIDs->Upper();
+
+ for (i = theSubShapeIDs->Lower(); i < aNbIDs; ++i) {
+ pd << theSubShapeIDs->Value(i) << ", ";
+ }
+
+ // Dump the last value without a comma.
+ pd << theSubShapeIDs->Value(i);
+ }
+
+ pd << "])";
+
+ SetErrorCode(OK);
+
+ return aResult;
+}
+
//=======================================================================
//function : getShapesOnSurfaceIDs
/*!
- * \brief Find IDs of subshapes complying with given status about surface
- * \param theSurface - the surface to check state of subshapes against
+ * \brief Find IDs of sub-shapes complying with given status about surface
+ * \param theSurface - the surface to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found subshapes
+ * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfInteger)
Handle(TColStd_HSequenceOfInteger) aSeqOfIDs;
// Check presence of triangulation, build if need
- if (!CheckTriangulation(theShape)) {
+ if (theShapeType != TopAbs_VERTEX &&
+ !GEOMUtils::CheckTriangulation(theShape)) {
SetErrorCode("Cannot build triangulation on the shape");
return aSeqOfIDs;
}
+ // BEGIN: Mantis issue 0020961: Error on a pipe T-Shape
+ // Compute tolerance
+ Standard_Real T, VertMax = -RealLast();
+ try {
+ OCC_CATCH_SIGNALS;
+ for (TopExp_Explorer ExV (theShape, TopAbs_VERTEX); ExV.More(); ExV.Next()) {
+ TopoDS_Vertex Vertex = TopoDS::Vertex(ExV.Current());
+ T = BRep_Tool::Tolerance(Vertex);
+ if (T > VertMax)
+ VertMax = T;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return aSeqOfIDs;
+ }
+ // END: Mantis issue 0020961
+
// Call algo
- GEOMAlgo_FinderShapeOn1 aFinder;
- Standard_Real aTol = 0.0001; // default value
+ GEOMAlgo_FinderShapeOn2 aFinder;
+ Handle(GEOMAlgo_ClsfSurf) aClsfSurf = new GEOMAlgo_ClsfSurf;
+ Standard_Real aTol = VertMax; // Mantis issue 0020961
+ aClsfSurf->SetSurface(theSurface);
aFinder.SetShape(theShape);
aFinder.SetTolerance(aTol);
- aFinder.SetSurface(theSurface);
+ aFinder.SetClsf(aClsfSurf);
aFinder.SetShapeType(theShapeType);
aFinder.SetState(theState);
// Default value=3
aFinder.SetNbPntsMin(3);
// Sets the maximal number of inner points for edges or faces.
- // It is usefull for the cases when this number is very big (e.g =2000) to improve
+ // It is useful for the cases when this number is very big (e.g =2000) to improve
// the performance. If this value =0, all inner points will be taken into account.
// Default value=0
aFinder.SetNbPntsMax(100);
aFinder.Perform();
- // Interprete results
+ // Interpret results
Standard_Integer iErr = aFinder.ErrorStatus();
- // the detailed description of error codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of error codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iErr) {
MESSAGE(" iErr : " << iErr);
TCollection_AsciiString aMsg (" iErr : ");
return aSeqOfIDs;
}
Standard_Integer iWrn = aFinder.WarningStatus();
- // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iWrn) {
MESSAGE(" *** iWrn : " << iWrn);
}
return aSeq;
}
+//=============================================================================
+/*!
+ * getSubShapeEdgeSortedIDs
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfInteger)
+ GEOMImpl_IShapesOperations::getSubShapeEdgeSortedIDs
+ (const Handle(GEOM_Object) &theShape,
+ const Handle(GEOM_Object) &theStartPoint)
+{
+ Handle(TColStd_HSequenceOfInteger) aResult;
+
+ if (theShape.IsNull() || theStartPoint.IsNull()) {
+ SetErrorCode("NULL GEOM object");
+ return aResult;
+ }
+
+ const TopoDS_Shape aShape = theShape->GetValue();
+ const TopoDS_Shape aStartPoint = theStartPoint->GetValue();
+
+ if (aShape.IsNull() || aStartPoint.IsNull()) {
+ SetErrorCode("NULL Shape");
+ return aResult;
+ }
+
+ if (aStartPoint.ShapeType() != TopAbs_VERTEX) {
+ SetErrorCode("Starting point is not a vertex");
+ return aResult;
+ }
+
+ TopExp_Explorer anExp(aShape, TopAbs_EDGE);
+ TopTools_MapOfShape aMapFence;
+ TopTools_ListOfShape anEdges;
+
+ for (; anExp.More(); anExp.Next()) {
+ const TopoDS_Shape &anEdge = anExp.Current();
+
+ if (aMapFence.Add(anEdge)) {
+ anEdges.Append(anEdge);
+ }
+ }
+
+ if (anEdges.IsEmpty()) {
+ SetErrorCode("Shape doesn't contain edges");
+ return aResult;
+ }
+
+ // Step 1: Sort edges
+ GEOMUtils::SortShapes(anEdges, Standard_False);
+
+ TopTools_ListIteratorOfListOfShape anIter(anEdges);
+ TopoDS_Vertex aV[2];
+ TopTools_DataMapOfShapeListOfShape aMapVE;
+
+ // Step 2: Fill the map vertex - list of edges.
+ for (; anIter.More(); anIter.Next()) {
+ TopoDS_Edge anEdge = TopoDS::Edge(anIter.Value());
+
+ TopExp::Vertices(anEdge, aV[0], aV[1]);
+
+ const Standard_Integer aNbV = aV[0].IsSame(aV[1]) ? 1 : 2;
+ Standard_Integer i;
+
+ for (i = 0; i < aNbV; ++i) {
+ if (aV[i].IsNull() == Standard_False) {
+ if (!aMapVE.IsBound(aV[i])) {
+ // There is no this vertex in the map.
+ aMapVE.Bind(aV[i], TopTools_ListOfShape());
+ }
+
+ // Add the edge to the list bound with the vertex aV[i].
+ TopTools_ListOfShape &aLEdges = aMapVE.ChangeFind(aV[i]);
+
+ aLEdges.Append(anEdge);
+ }
+ }
+ }
+
+ // Step 3: Find starting point in aMapVE.
+ TopoDS_Vertex aStartVtx = TopoDS::Vertex(aStartPoint);
+
+ if (!aMapVE.IsBound(aStartVtx)) {
+ aStartVtx = getSameVertex(aShape, aStartVtx);
+
+ if (aStartVtx.IsNull()) {
+ SetErrorCode("Invalid Starting point");
+ return aResult;
+ }
+ }
+
+ TopTools_IndexedMapOfShape anIndices;
+ TopTools_MapOfShape aMapVFence;
+ TopoDS_Shape aCurVtx = aStartVtx;
+ TopoDS_Edge aCurEdge =
+ TopoDS::Edge(aMapVE.Find(aCurVtx).First());
+
+ aResult = new TColStd_HSequenceOfInteger;
+ TopExp::MapShapes(aShape, anIndices);
+
+ // Step 4: Fill the list of sorted edges.
+ while (aMapVFence.Add(aCurVtx)) {
+ // Append the ID of the current edge to the list of sorted.
+ aResult->Append(anIndices.FindIndex(aCurEdge));
+ TopExp::Vertices(aCurEdge, aV[0], aV[1]);
+
+ // Get the next vertex.
+ if (aCurVtx.IsSame(aV[0])) {
+ if (aCurVtx.IsSame(aV[1])) {
+ // There is no next vertex.
+ break;
+ } else {
+ aCurVtx = aV[1];
+ }
+ } else {
+ aCurVtx = aV[0];
+ }
+
+ if (aCurVtx.IsNull()) {
+ // There is no next vertex.
+ break;
+ }
+
+ // Get the next edge.
+ const TopTools_ListOfShape &aLEdges = aMapVE.Find(aCurVtx);
+ TopTools_ListIteratorOfListOfShape anEIter(aLEdges);
+
+ for (; anEIter.More(); anEIter.Next()) {
+ const TopoDS_Shape &aLocalEdge = anEIter.Value();
+
+ if (aLocalEdge.IsNull() == Standard_False) {
+ if (!aCurEdge.IsSame(aLocalEdge)) {
+ aCurEdge = TopoDS::Edge(aLocalEdge);
+ break;
+ }
+ }
+ }
+
+ if (!anEIter.More()) {
+ // There is no next edge.
+ break;
+ }
+ }
+
+ return aResult;
+}
+
//=======================================================================
//function : getShapesOnSurface
/*!
- * \brief Find subshapes complying with given status about surface
- * \param theSurface - the surface to check state of subshapes against
+ * \brief Find sub-shapes complying with given status about surface
+ * \param theSurface - the surface to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
* \param theShapeEntries - outgoing entries like "entry1, entry2, ..."
- * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found subshapes
+ * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfTransient)
GEOMAlgo_State theState,
TCollection_AsciiString & theShapeEntries)
{
- // Find subshapes ids
+ // Find sub-shapes ids
Handle(TColStd_HSequenceOfInteger) aSeqOfIDs =
getShapesOnSurfaceIDs (theSurface, theShape->GetValue(), theShapeType, theState);
if ( aSeqOfIDs.IsNull() || aSeqOfIDs->Length() == 0 )
(const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAx1,
- const Handle(GEOM_Object)& thePnt,
+ const Handle(GEOM_Object)& thePnt,
const GEOMAlgo_State theState)
{
SetErrorCode(KO);
gp_Pnt aLoc = BRep_Tool::Pnt(V3);
gp_Vec aVec(BRep_Tool::Pnt(V1),BRep_Tool::Pnt(V2));
- if (aVec.Magnitude() < Precision::Confusion()) {
- SetErrorCode("Vector with null magnitude given");
+ if (aVec.Magnitude() < Precision::Confusion()) {
+ SetErrorCode("Vector with null magnitude given");
+ return NULL;
+ }
+ Handle(Geom_Surface) aPlane = new Geom_Plane(aLoc, aVec);
+
+ if ( aPlane.IsNull() )
+ return NULL;
+
+ // Find objects
+ TCollection_AsciiString anAsciiList;
+ Handle(TColStd_HSequenceOfTransient) aSeq;
+ aSeq = getShapesOnSurface( aPlane, theShape, aShapeType, theState, anAsciiList );
+ if ( aSeq.IsNull() || aSeq->Length() == 0 )
+ return NULL;
+
+ // Make a Python command
+
+ Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast( aSeq->Value( 1 ));
+ Handle(GEOM_Function) aFunction = anObj->GetLastFunction();
+
+ GEOM::TPythonDump(aFunction) << "[" << anAsciiList.ToCString()
+ << "] = geompy.GetShapesOnPlaneWithLocation(" << theShape << ", "
+ << aShapeType << ", " << theAx1 << ", "<< thePnt <<", " << theState << ")";
+
+ SetErrorCode(OK);
+ return aSeq;
+}
+
+//=============================================================================
+/*!
+ * GetShapesOnCylinder
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetShapesOnCylinder
+ (const Handle(GEOM_Object)& theShape,
+ const Standard_Integer theShapeType,
+ const Handle(GEOM_Object)& theAxis,
+ const Standard_Real theRadius,
+ const GEOMAlgo_State theState)
+{
+ SetErrorCode(KO);
+
+ if (theShape.IsNull() || theAxis.IsNull()) return NULL;
+
+ TopoDS_Shape aShape = theShape->GetValue();
+ TopoDS_Shape anAxis = theAxis->GetValue();
+
+ if (aShape.IsNull() || anAxis.IsNull()) return NULL;
+
+ TopAbs_ShapeEnum aShapeType = TopAbs_ShapeEnum(theShapeType);
+ if ( !checkTypeShapesOn( aShapeType ))
return NULL;
- }
- Handle(Geom_Surface) aPlane = new Geom_Plane(aLoc, aVec);
- if ( aPlane.IsNull() )
+ // Create a cylinder surface
+ Handle(Geom_Surface) aCylinder = makeCylinder( anAxis, theRadius );
+ if ( aCylinder.IsNull() )
return NULL;
// Find objects
TCollection_AsciiString anAsciiList;
Handle(TColStd_HSequenceOfTransient) aSeq;
- aSeq = getShapesOnSurface( aPlane, theShape, aShapeType, theState, anAsciiList );
+ aSeq = getShapesOnSurface( aCylinder, theShape, aShapeType, theState, anAsciiList );
if ( aSeq.IsNull() || aSeq->Length() == 0 )
return NULL;
Handle(GEOM_Function) aFunction = anObj->GetLastFunction();
GEOM::TPythonDump(aFunction) << "[" << anAsciiList.ToCString()
- << "] = geompy.GetShapesOnPlaneWithLocation(" << theShape << ", "
- << aShapeType << ", " << theAx1 << ", "<< thePnt <<", " << theState << ")";
+ << "] = geompy.GetShapesOnCylinder(" << theShape << ", " << aShapeType
+ << ", " << theAxis << ", " << theRadius << ", " << theState << ")";
SetErrorCode(OK);
return aSeq;
//=============================================================================
/*!
- * GetShapesOnCylinder
+ * GetShapesOnCylinderWithLocation
*/
//=============================================================================
-Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetShapesOnCylinder
+Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetShapesOnCylinderWithLocation
(const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAxis,
+ const Handle(GEOM_Object)& thePnt,
const Standard_Real theRadius,
const GEOMAlgo_State theState)
{
SetErrorCode(KO);
- if (theShape.IsNull() || theAxis.IsNull()) return NULL;
+ if (theShape.IsNull() || theAxis.IsNull() || thePnt.IsNull()) return NULL;
TopoDS_Shape aShape = theShape->GetValue();
TopoDS_Shape anAxis = theAxis->GetValue();
+ TopoDS_Shape aPnt = thePnt->GetValue();
- if (aShape.IsNull() || anAxis.IsNull()) return NULL;
+ if (aShape.IsNull() || anAxis.IsNull() || aPnt.IsNull()) return NULL;
+
+ if (aPnt.ShapeType() != TopAbs_VERTEX )
+ {
+ SetErrorCode("Bottom location point must be vertex");
+ return NULL;
+ }
TopAbs_ShapeEnum aShapeType = TopAbs_ShapeEnum(theShapeType);
if ( !checkTypeShapesOn( aShapeType ))
if ( aCylinder.IsNull() )
return NULL;
+ // translate the surface
+ Handle(Geom_CylindricalSurface) aCylSurface =
+ Handle(Geom_CylindricalSurface)::DownCast( aCylinder );
+ if ( aCylSurface.IsNull() )
+ {
+ SetErrorCode("Unexpected surface type instead of Geom_CylindricalSurface");
+ return NULL;
+ }
+ gp_Pnt fromLoc = aCylSurface->Cylinder().Location();
+ gp_Pnt toLoc = BRep_Tool::Pnt( TopoDS::Vertex( aPnt ));
+ aCylinder->Translate( fromLoc, toLoc );
+
// Find objects
TCollection_AsciiString anAsciiList;
Handle(TColStd_HSequenceOfTransient) aSeq;
Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast( aSeq->Value( 1 ));
Handle(GEOM_Function) aFunction = anObj->GetLastFunction();
- GEOM::TPythonDump(aFunction) << "[" << anAsciiList.ToCString()
- << "] = geompy.GetShapesOnCylinder(" << theShape << ", " << aShapeType
- << ", " << theAxis << ", " << theRadius << ", " << theState << ")";
+ GEOM::TPythonDump(aFunction)
+ << "[" << anAsciiList.ToCString()
+ << "] = geompy.GetShapesOnCylinderWithLocation(" << theShape << ", " << aShapeType << ", "
+ << theAxis << ", " << thePnt << ", " << theRadius << ", " << theState << ")";
SetErrorCode(OK);
return aSeq;
// The GetShapesOnPlaneIDs() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theAx1)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnPlane = geompy.GetShapesOnPlaneIDs"
<< "(" << theShape << "," << aShapeType << "," << theAx1 << "," << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
(const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAx1,
- const Handle(GEOM_Object)& thePnt,
+ const Handle(GEOM_Object)& thePnt,
const GEOMAlgo_State theState)
{
SetErrorCode(KO);
// The GetShapesOnPlaneIDs() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theAx1)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnPlane = geompy.GetShapesOnPlaneWithLocationIDs"
<< "(" << theShape << ", " << aShapeType << ", " << theAx1 << ", "<< thePnt << ", " << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
// The GetShapesOnCylinder() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theAxis)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnCylinder = geompy.GetShapesOnCylinderIDs"
<< "(" << theShape << ", " << aShapeType << ", " << theAxis << ", "
<< theRadius << ", " << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
+
+ SetErrorCode(OK);
+ return aSeq;
+}
+
+//=============================================================================
+/*!
+ * GetShapesOnCylinderWithLocationIDs
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfInteger) GEOMImpl_IShapesOperations::GetShapesOnCylinderWithLocationIDs
+ (const Handle(GEOM_Object)& theShape,
+ const Standard_Integer theShapeType,
+ const Handle(GEOM_Object)& theAxis,
+ const Handle(GEOM_Object)& thePnt,
+ const Standard_Real theRadius,
+ const GEOMAlgo_State theState)
+{
+ SetErrorCode(KO);
+
+ if (theShape.IsNull() || theAxis.IsNull() || thePnt.IsNull()) return NULL;
+
+ TopoDS_Shape aShape = theShape->GetValue();
+ TopoDS_Shape anAxis = theAxis->GetValue();
+ TopoDS_Shape aPnt = thePnt->GetValue();
+
+ if (aShape.IsNull() || anAxis.IsNull() || aPnt.IsNull()) return NULL;
+
+ if (aPnt.ShapeType() != TopAbs_VERTEX )
+ {
+ SetErrorCode("Bottom location point must be vertex");
+ return NULL;
+ }
+
+ TopAbs_ShapeEnum aShapeType = TopAbs_ShapeEnum(theShapeType);
+ if ( !checkTypeShapesOn( aShapeType ))
+ return NULL;
+
+ // Create a cylinder surface
+ Handle(Geom_Surface) aCylinder = makeCylinder( anAxis, theRadius );
+ if ( aCylinder.IsNull() )
+ return NULL;
+
+ // translate the surface
+ Handle(Geom_CylindricalSurface) aCylSurface =
+ Handle(Geom_CylindricalSurface)::DownCast( aCylinder );
+ if ( aCylSurface.IsNull() )
+ {
+ SetErrorCode("Unexpected surface type instead of Geom_CylindricalSurface");
+ return NULL;
+ }
+ gp_Pnt fromLoc = aCylSurface->Cylinder().Location();
+ gp_Pnt toLoc = BRep_Tool::Pnt( TopoDS::Vertex( aPnt ));
+ aCylinder->Translate( fromLoc, toLoc );
+
+ // Find object IDs
+ Handle(TColStd_HSequenceOfInteger) aSeq;
+ aSeq = getShapesOnSurfaceIDs( aCylinder, aShape, aShapeType, theState );
+
+ // The GetShapesOnCylinder() doesn't change object so no new function is required.
+ Handle(GEOM_Function) aFunction =
+ GEOM::GetCreatedLast(theShape, GEOM::GetCreatedLast(thePnt,theAxis))->GetLastFunction();
+
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
+ // Make a Python command
+ GEOM::TPythonDump(aFunction, /*append=*/true)
+ << "listShapesOnCylinder = geompy.GetShapesOnCylinderWithLocationIDs"
+ << "(" << theShape << ", " << aShapeType << ", " << theAxis << ", "
+ << thePnt << ", " << theRadius << ", " << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
// The GetShapesOnSphere() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theCenter)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
- << "listShapesOnCylinder = geompy.GetShapesOnCylinderIDs"
+ << "listShapesOnSphere = geompy.GetShapesOnSphereIDs"
<< "(" << theShape << ", " << aShapeType << ", " << theCenter << ", "
<< theRadius << ", " << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
//=======================================================================
//function : getShapesOnQuadrangleIDs
/*!
- * \brief Find IDs of subshapes complying with given status about quadrangle
+ * \brief Find IDs of sub-shapes complying with given status about quadrangle
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theTopLeftPoint - top left quadrangle corner
- * \param theTopRigthPoint - top right quadrangle corner
+ * \param theTopRightPoint - top right quadrangle corner
* \param theBottomLeftPoint - bottom left quadrangle corner
- * \param theBottomRigthPoint - bottom right quadrangle corner
+ * \param theBottomRightPoint - bottom right quadrangle corner
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found subshapes
+ * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfInteger)
GEOMImpl_IShapesOperations::getShapesOnQuadrangleIDs (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theTopLeftPoint,
- const Handle(GEOM_Object)& theTopRigthPoint,
+ const Handle(GEOM_Object)& theTopRightPoint,
const Handle(GEOM_Object)& theBottomLeftPoint,
- const Handle(GEOM_Object)& theBottomRigthPoint,
+ const Handle(GEOM_Object)& theBottomRightPoint,
const GEOMAlgo_State theState)
{
SetErrorCode(KO);
if ( theShape.IsNull() ||
theTopLeftPoint.IsNull() ||
- theTopRigthPoint.IsNull() ||
+ theTopRightPoint.IsNull() ||
theBottomLeftPoint.IsNull() ||
- theBottomRigthPoint.IsNull() )
+ theBottomRightPoint.IsNull() )
return NULL;
TopoDS_Shape aShape = theShape->GetValue();
TopoDS_Shape aTL = theTopLeftPoint->GetValue();
- TopoDS_Shape aTR = theTopRigthPoint->GetValue();
+ TopoDS_Shape aTR = theTopRightPoint->GetValue();
TopoDS_Shape aBL = theBottomLeftPoint->GetValue();
- TopoDS_Shape aBR = theBottomRigthPoint->GetValue();
+ TopoDS_Shape aBR = theBottomRightPoint->GetValue();
if (aShape.IsNull() ||
aTL.IsNull() ||
Handle(TColStd_HSequenceOfInteger) aSeqOfIDs;
// Check presence of triangulation, build if need
- if (!CheckTriangulation(aShape)) {
+ if (theShapeType != TopAbs_VERTEX && !GEOMUtils::CheckTriangulation(aShape)) {
SetErrorCode("Cannot build triangulation on the shape");
return aSeqOfIDs;
}
gp_Pnt aPntBL = BRep_Tool::Pnt(TopoDS::Vertex(aBL));
gp_Pnt aPntBR = BRep_Tool::Pnt(TopoDS::Vertex(aBR));
- GEOMAlgo_FinderShapeOnQuad aFinder( aPntTL, aPntTR, aPntBL, aPntBR );
+ GEOMAlgo_FinderShapeOn2 aFinder;
+ Handle(GEOMAlgo_ClsfQuad) aClsfQuad = new GEOMAlgo_ClsfQuad;
+
Standard_Real aTol = 0.0001; // default value
+ aClsfQuad->SetCorners(aPntTL, aPntTR, aPntBL, aPntBR);
aFinder.SetShape(aShape);
aFinder.SetTolerance(aTol);
- //aFinder.SetSurface(theSurface);
+ aFinder.SetClsf(aClsfQuad);
aFinder.SetShapeType(aShapeType);
aFinder.SetState(theState);
// Default value=3
aFinder.SetNbPntsMin(3);
// Sets the maximal number of inner points for edges or faces.
- // It is usefull for the cases when this number is very big (e.g =2000) to improve
+ // It is useful for the cases when this number is very big (e.g =2000) to improve
// the performance. If this value =0, all inner points will be taken into account.
// Default value=0
aFinder.SetNbPntsMax(100);
aFinder.Perform();
- // Interprete results
+ // Interpret results
Standard_Integer iErr = aFinder.ErrorStatus();
- // the detailed description of error codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of error codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iErr) {
MESSAGE(" iErr : " << iErr);
TCollection_AsciiString aMsg (" iErr : ");
return aSeqOfIDs;
}
Standard_Integer iWrn = aFinder.WarningStatus();
- // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iWrn) {
MESSAGE(" *** iWrn : " << iWrn);
}
//=======================================================================
//function : GetShapesOnQuadrangle
/*!
- * \brief Find subshapes complying with given status about quadrangle
+ * \brief Find sub-shapes complying with given status about quadrangle
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theTopLeftPoint - top left quadrangle corner
- * \param theTopRigthPoint - top right quadrangle corner
+ * \param theTopRightPoint - top right quadrangle corner
* \param theBottomLeftPoint - bottom left quadrangle corner
- * \param theBottomRigthPoint - bottom right quadrangle corner
+ * \param theBottomRightPoint - bottom right quadrangle corner
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found subshapes
+ * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfTransient)
GEOMImpl_IShapesOperations::GetShapesOnQuadrangle (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theTopLeftPoint,
- const Handle(GEOM_Object)& theTopRigthPoint,
+ const Handle(GEOM_Object)& theTopRightPoint,
const Handle(GEOM_Object)& theBottomLeftPoint,
- const Handle(GEOM_Object)& theBottomRigthPoint,
+ const Handle(GEOM_Object)& theBottomRightPoint,
const GEOMAlgo_State theState)
{
// Find indices
getShapesOnQuadrangleIDs( theShape,
theShapeType,
theTopLeftPoint,
- theTopRigthPoint,
+ theTopRightPoint,
theBottomLeftPoint,
- theBottomRigthPoint,
+ theBottomRightPoint,
theState);
if ( aSeqOfIDs.IsNull() || aSeqOfIDs->IsEmpty() )
return NULL;
<< theShape << ", "
<< TopAbs_ShapeEnum(theShapeType) << ", "
<< theTopLeftPoint << ", "
- << theTopRigthPoint << ", "
+ << theTopRightPoint << ", "
<< theBottomLeftPoint << ", "
- << theBottomRigthPoint << ", "
+ << theBottomRightPoint << ", "
<< theState << ")";
SetErrorCode(OK);
//=======================================================================
//function : GetShapesOnQuadrangleIDs
/*!
- * \brief Find IDs of subshapes complying with given status about quadrangle
+ * \brief Find IDs of sub-shapes complying with given status about quadrangle
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theTopLeftPoint - top left quadrangle corner
- * \param theTopRigthPoint - top right quadrangle corner
+ * \param theTopRightPoint - top right quadrangle corner
* \param theBottomLeftPoint - bottom left quadrangle corner
- * \param theBottomRigthPoint - bottom right quadrangle corner
+ * \param theBottomRightPoint - bottom right quadrangle corner
* \param theState - required state
- * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found subshapes
+ * \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
//=======================================================================
Handle(TColStd_HSequenceOfInteger)
GEOMImpl_IShapesOperations::GetShapesOnQuadrangleIDs (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theTopLeftPoint,
- const Handle(GEOM_Object)& theTopRigthPoint,
+ const Handle(GEOM_Object)& theTopRightPoint,
const Handle(GEOM_Object)& theBottomLeftPoint,
- const Handle(GEOM_Object)& theBottomRigthPoint,
+ const Handle(GEOM_Object)& theBottomRightPoint,
const GEOMAlgo_State theState)
{
// Find indices
getShapesOnQuadrangleIDs( theShape,
theShapeType,
theTopLeftPoint,
- theTopRigthPoint,
+ theTopRightPoint,
theBottomLeftPoint,
- theBottomRigthPoint,
+ theBottomRightPoint,
theState);
if ( aSeqOfIDs.IsNull() || aSeqOfIDs->IsEmpty() )
return NULL;
// Make a Python command
// The GetShapesOnCylinder() doesn't change object so no new function is required.
- Handle(GEOM_Object) lastObj = GEOM::GetCreatedLast(theShape,theTopLeftPoint);
- lastObj = GEOM::GetCreatedLast(lastObj,theTopRigthPoint);
- lastObj = GEOM::GetCreatedLast(lastObj,theBottomRigthPoint);
+ Handle(GEOM_BaseObject) lastObj = GEOM::GetCreatedLast(theShape,theTopLeftPoint);
+ lastObj = GEOM::GetCreatedLast(lastObj,theTopRightPoint);
+ lastObj = GEOM::GetCreatedLast(lastObj,theBottomRightPoint);
lastObj = GEOM::GetCreatedLast(lastObj,theBottomLeftPoint);
Handle(GEOM_Function) aFunction = lastObj->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnQuadrangle = geompy.GetShapesOnQuadrangleIDs("
<< theShape << ", "
<< TopAbs_ShapeEnum(theShapeType) << ", "
<< theTopLeftPoint << ", "
- << theTopRigthPoint << ", "
+ << theTopRightPoint << ", "
<< theBottomLeftPoint << ", "
- << theBottomRigthPoint << ", "
+ << theBottomRightPoint << ", "
<< theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeqOfIDs;
//=============================================================================
/*!
- * GetInPlaceOfShape
+ * case GetInPlace:
+ * default:
*/
//=============================================================================
-static bool GetInPlaceOfShape (const Handle(GEOM_Function)& theWhereFunction,
- const TopTools_IndexedMapOfShape& theWhereIndices,
- const TopoDS_Shape& theWhat,
- TColStd_ListOfInteger& theModifiedList)
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::GetInPlace (Handle(GEOM_Object) theShapeWhere,
+ Handle(GEOM_Object) theShapeWhat)
{
- if (theWhereFunction.IsNull() || theWhat.IsNull()) return false;
+ SetErrorCode(KO);
- if (theWhereIndices.Contains(theWhat)) {
- // entity was not changed by the operation
- Standard_Integer aWhatIndex = theWhereIndices.FindIndex(theWhat);
- theModifiedList.Append(aWhatIndex);
- return true;
- }
+ if (theShapeWhere.IsNull() || theShapeWhat.IsNull()) return NULL;
+
+ TopoDS_Shape aWhere = theShapeWhere->GetValue();
+ TopoDS_Shape aWhat = theShapeWhat->GetValue();
- // try to find in history
- TDF_Label aHistoryLabel = theWhereFunction->GetHistoryEntry(Standard_False);
+ if (aWhere.IsNull() || aWhat.IsNull()) {
+ SetErrorCode("Error: aWhere and aWhat TopoDS_Shape are Null.");
+ return NULL;
+ }
- // search in history for all argument shapes
- Standard_Boolean isFound = Standard_False;
- Standard_Boolean isGood = Standard_False;
+ // Searching for the sub-shapes inside the ShapeWhere shape
+ GEOMAlgo_GetInPlace aGIP;
- TDF_LabelSequence aLabelSeq;
- theWhereFunction->GetDependency(aLabelSeq);
- Standard_Integer nbArg = aLabelSeq.Length();
+ if (!GEOMAlgo_GetInPlaceAPI::GetInPlace(aWhere, aWhat, aGIP)) {
+ SetErrorCode("Error in GEOMAlgo_GetInPlace");
+ return NULL;
+ }
- for (Standard_Integer iarg = 1; iarg <= nbArg && !isFound; iarg++) {
+ // Add direct result.
+ TopTools_ListOfShape aLSA;
+ const TopoDS_Shape &aShapeResult = aGIP.Result();
+ TopTools_MapOfShape aMFence;
+ TopTools_IndexedMapOfShape aWhereIndices;
+ Standard_Integer aShapeType = -1;
- TDF_Label anArgumentRefLabel = aLabelSeq.Value(iarg);
+ TopExp::MapShapes(aWhere, aWhereIndices);
- Handle(GEOM_Object) anArgumentObject = GEOM_Object::GetReferencedObject(anArgumentRefLabel);
- TopoDS_Shape anArgumentShape = anArgumentObject->GetValue();
+ if (aShapeResult.IsNull() == Standard_False) {
+ TopoDS_Iterator anIt(aShapeResult);
- TopTools_IndexedMapOfShape anArgumentIndices;
- TopExp::MapShapes(anArgumentShape, anArgumentIndices);
+ for (; anIt.More(); anIt.Next()) {
+ const TopoDS_Shape &aPart = anIt.Value();
- if (anArgumentIndices.Contains(theWhat)) {
- isFound = Standard_True;
- Standard_Integer aWhatIndex = anArgumentIndices.FindIndex(theWhat);
+ if(aWhereIndices.Contains(aPart) && aMFence.Add(aPart)) {
+ const TopAbs_ShapeEnum aType = aPart.ShapeType();
- // Find corresponding label in history
- TDF_Label anArgumentHistoryLabel =
- theWhereFunction->GetArgumentHistoryEntry(anArgumentRefLabel, Standard_False);
- if (anArgumentHistoryLabel.IsNull()) {
- // Lost History of operation argument. Possibly, all its entities was removed.
- isGood = Standard_True;
- }
- else {
- TDF_Label aWhatHistoryLabel = anArgumentHistoryLabel.FindChild(aWhatIndex, Standard_False);
-
- if (aWhatHistoryLabel.IsNull()) {
- // Removed entity ? Compound ? Compsolid ? Shell ? Wire
- isGood = Standard_False;
- } else {
- Handle(TDataStd_IntegerArray) anIntegerArray;
- if (!aWhatHistoryLabel.FindAttribute(TDataStd_IntegerArray::GetID(), anIntegerArray)) {
- //Error: Empty modifications history for the sought shape.
- isGood = Standard_False;
- }
- else {
- isGood = Standard_True;
- Standard_Integer imod, aModifLen = anIntegerArray->Array()->Length();
- for (imod = 1; imod <= aModifLen; imod++) {
- theModifiedList.Append(anIntegerArray->Array()->Value(imod));
- }
- }
+ if (aShapeType == -1) {
+ // Initialization.
+ aShapeType = aType;
+ } else if (aShapeType != TopAbs_SHAPE && aShapeType != aType) {
+ // Different types.
+ aShapeType = TopAbs_SHAPE;
}
+
+ aLSA.Append(aPart);
}
}
}
- isFound = isGood;
+ if (aLSA.Extent() == 0) {
+ SetErrorCode(NOT_FOUND_ANY); // Not found any Results
+ return NULL;
+ }
- if (!isFound) {
- // try compound/compsolid/shell/wire element by element
- bool isFoundAny = false;
- TopTools_MapOfShape mapShape;
+ Handle(TColStd_HArray1OfInteger) aModifiedArray = new TColStd_HArray1OfInteger (1, aLSA.Extent());
+ TopTools_ListIteratorOfListOfShape anIterModif (aLSA);
+ for (Standard_Integer imod = 1; anIterModif.More(); anIterModif.Next(), imod++) {
+ aModifiedArray->SetValue(imod, aWhereIndices.FindIndex(anIterModif.Value()));
+ }
- if (theWhat.ShapeType() == TopAbs_COMPOUND ||
- theWhat.ShapeType() == TopAbs_COMPSOLID) {
- // recursive processing of compound/compsolid
- TopoDS_Iterator anIt (theWhat, Standard_True, Standard_True);
- for (; anIt.More(); anIt.Next()) {
- if (mapShape.Add(anIt.Value())) {
- TopoDS_Shape curWhat = anIt.Value();
- isFoundAny = GetInPlaceOfShape(theWhereFunction, theWhereIndices, curWhat, theModifiedList);
- if (isFoundAny) isFound = Standard_True;
- }
- }
- }
- else if (theWhat.ShapeType() == TopAbs_SHELL) {
- // try to replace a shell by its faces images
- TopExp_Explorer anExp (theWhat, TopAbs_FACE);
- for (; anExp.More(); anExp.Next()) {
- if (mapShape.Add(anExp.Current())) {
- TopoDS_Shape curWhat = anExp.Current();
- isFoundAny = GetInPlaceOfShape(theWhereFunction, theWhereIndices, curWhat, theModifiedList);
- if (isFoundAny) isFound = Standard_True;
- }
- }
- }
- else if (theWhat.ShapeType() == TopAbs_WIRE) {
- // try to replace a wire by its edges images
- TopExp_Explorer anExp (theWhat, TopAbs_EDGE);
- for (; anExp.More(); anExp.Next()) {
- if (mapShape.Add(anExp.Current())) {
- TopoDS_Shape curWhat = anExp.Current();
- isFoundAny = GetInPlaceOfShape(theWhereFunction, theWhereIndices, curWhat, theModifiedList);
- if (isFoundAny) isFound = Standard_True;
- }
- }
- }
- else {
- // Removed entity
- }
+ //Add a new object
+ Handle(GEOM_Object) aResult = GetEngine()->AddSubShape(theShapeWhere, aModifiedArray);
+ if (aResult.IsNull()) {
+ SetErrorCode("Error in algorithm: result found, but cannot be returned.");
+ return NULL;
}
- return isFound;
-}
+ const Standard_Boolean isSameType = (aShapeType != TopAbs_SHAPE);
-//=============================================================================
-/*!
- * GetShapeProperties
- */
-//=============================================================================
-void GEOMImpl_IShapesOperations::GetShapeProperties( const TopoDS_Shape aShape, Standard_Real tab[],
- gp_Pnt & aVertex )
-{
- GProp_GProps theProps;
- gp_Pnt aCenterMass;
- TopoDS_Shape aPntShape;
- Standard_Real aShapeSize;
+ if ((aModifiedArray->Length() > 1 && isSameType) ||
+ theShapeWhat->GetType() == GEOM_GROUP) {
+ //Set a GROUP type
+ aResult->SetType(GEOM_GROUP);
- if (aShape.ShapeType() == TopAbs_EDGE) BRepGProp::LinearProperties(aShape, theProps);
- else if (aShape.ShapeType() == TopAbs_FACE) BRepGProp::SurfaceProperties(aShape, theProps);
- else BRepGProp::VolumeProperties(aShape, theProps);
+ //Set a sub-shape type
+ TopoDS_Shape aFirstFound = aLSA.First();
+ TopAbs_ShapeEnum aShapeType = aFirstFound.ShapeType();
- aCenterMass = theProps.CentreOfMass();
- aShapeSize = theProps.Mass();
+ TDF_Label aFreeLabel = aResult->GetFreeLabel();
+ TDataStd_Integer::Set(aFreeLabel, (Standard_Integer)aShapeType);
+ }
- aPntShape = BRepBuilderAPI_MakeVertex(aCenterMass).Shape();
- aVertex = BRep_Tool::Pnt( TopoDS::Vertex( aPntShape ) );
- tab[0] = aVertex.X();
- tab[1] = aVertex.Y();
- tab[2] = aVertex.Z();
- tab[3] = aShapeSize;
- return;
+ //Make a Python command
+ Handle(GEOM_Function) aFunction = aResult->GetFunction(1);
+
+ GEOM::TPythonDump(aFunction) << aResult << " = geompy.GetInPlace("
+ << theShapeWhere << ", " << theShapeWhat << ", True)";
+
+ SetErrorCode(OK);
+ return aResult;
}
//=============================================================================
/*!
- * GetInPlace
+ * case GetInPlaceOld:
+ * default:
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IShapesOperations::GetInPlace (Handle(GEOM_Object) theShapeWhere,
- Handle(GEOM_Object) theShapeWhat)
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::GetInPlaceOld
+ (Handle(GEOM_Object) theShapeWhere,
+ Handle(GEOM_Object) theShapeWhat)
{
SetErrorCode(KO);
if (theShapeWhere.IsNull() || theShapeWhat.IsNull()) return NULL;
- TopoDS_Shape aWhere = theShapeWhere->GetValue();
- TopoDS_Shape aWhat = theShapeWhat->GetValue();
- TopoDS_Shape aPntShape;
- TopoDS_Vertex aVertex;
+ TopoDS_Shape aWhere = theShapeWhere->GetValue();
+ TopoDS_Shape aWhat = theShapeWhat->GetValue();
+ TopTools_ListOfShape aModifiedList;
+ const Standard_Integer iErr =
+ GEOMAlgo_GetInPlaceAPI::GetInPlaceOld(aWhere, aWhat, aModifiedList);
- if (aWhere.IsNull() || aWhat.IsNull()) {
- SetErrorCode("Error: aWhere and aWhat TopoDS_Shape are Null.");
- return NULL;
- }
+ if (iErr) {
+ switch (iErr) {
+ case 1:
+ SetErrorCode("Error: aWhere and aWhat TopoDS_Shape are Null.");
+ break;
+ case 2:
+ SetErrorCode
+ ("Error: An attempt to extract a shape of not supported type.");
+ break;
+ case 3:
+ SetErrorCode(NOT_FOUND_ANY);
+ break;
+ default:
+ SetErrorCode("Shape driver failed");
+ break;
+ }
- Handle(GEOM_Function) aWhereFunction = theShapeWhere->GetLastFunction();
- if (aWhereFunction.IsNull()) {
- SetErrorCode("Error: aWhereFunction is Null.");
return NULL;
}
TopTools_IndexedMapOfShape aWhereIndices;
TopExp::MapShapes(aWhere, aWhereIndices);
- TColStd_ListOfInteger aModifiedList;
- Standard_Integer aWhereIndex;
- Handle(TColStd_HArray1OfInteger) aModifiedArray;
- Handle(GEOM_Object) aResult;
-
- bool isFound = false;
- Standard_Integer iType = TopAbs_SOLID;
- Standard_Integer compType = TopAbs_SOLID;
- Standard_Real aWhat_Mass = 0., aWhere_Mass = 0.;
- Standard_Real tab_aWhat[4], tab_aWhere[4];
- Standard_Real dl_l = 1e-3;
- Standard_Real min_l, Tol_1D, Tol_2D, Tol_3D, Tol_Mass;
- Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
- Bnd_Box BoundingBox;
- gp_Pnt aPnt, aPnt_aWhat, tab_Pnt[2];
- GProp_GProps aProps;
-
- // Find the iType of the aWhat shape
- if ( aWhat.ShapeType() == TopAbs_EDGE || aWhat.ShapeType() == TopAbs_WIRE ) iType = TopAbs_EDGE;
- else if ( aWhat.ShapeType() == TopAbs_FACE || aWhat.ShapeType() == TopAbs_SHELL ) iType = TopAbs_FACE;
- else if ( aWhat.ShapeType() == TopAbs_SOLID || aWhat.ShapeType() == TopAbs_COMPSOLID ) iType = TopAbs_SOLID;
- else if ( aWhat.ShapeType() == TopAbs_COMPOUND ) {
- // Only the iType of the first shape in the compound is taken into account
- TopoDS_Iterator It (aWhat, Standard_True, Standard_True);
- compType = It.Value().ShapeType();
- if ( compType == TopAbs_EDGE || compType == TopAbs_WIRE ) iType = TopAbs_EDGE;
- else if ( compType == TopAbs_FACE || compType == TopAbs_SHELL) iType = TopAbs_FACE;
- else if ( compType == TopAbs_SOLID || compType == TopAbs_COMPSOLID) iType = TopAbs_SOLID;
- }
- else {
- SetErrorCode("Error: An attempt to extract a shape of not supported type.");
- return NULL;
- }
-
- TopExp_Explorer Exp_aWhat( aWhat, TopAbs_ShapeEnum( iType ) );
- TopExp_Explorer Exp_aWhere( aWhere, TopAbs_ShapeEnum( iType ) );
- TopExp_Explorer Exp_Edge( aWhere, TopAbs_EDGE );
-
- // Find the shortest edge in theShapeWhere shape
- BRepBndLib::Add(aWhere, BoundingBox);
- BoundingBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
- min_l = fabs(aXmax - aXmin);
- if( min_l < fabs(aYmax - aYmin) ) min_l = fabs(aYmax - aYmin);
- if( min_l < fabs(aZmax - aZmin) ) min_l = fabs(aZmax - aZmin);
- min_l /= dl_l;
- for ( Standard_Integer nbEdge = 0; Exp_Edge.More(); Exp_Edge.Next(), nbEdge++ ) {
- TopExp_Explorer Exp_Vertex( Exp_Edge.Current(), TopAbs_VERTEX);
- for ( Standard_Integer nbVertex = 0; Exp_Vertex.More(); Exp_Vertex.Next(), nbVertex++ ) {
- aPnt = BRep_Tool::Pnt( TopoDS::Vertex( Exp_Vertex.Current() ) );
- tab_Pnt[nbVertex] = aPnt;
- }
- if ( ! tab_Pnt[0].IsEqual(tab_Pnt[1], dl_l) ) {
- BRepGProp::LinearProperties(Exp_Edge.Current(), aProps);
- if ( aProps.Mass() < min_l ) min_l = aProps.Mass();
- }
- }
-
- // Compute tolerances
- Tol_1D = dl_l * min_l;
- Tol_2D = dl_l * ( min_l * min_l) * ( 2. + dl_l);
- Tol_3D = dl_l * ( min_l * min_l * min_l ) * ( 3. + (3 * dl_l) + (dl_l * dl_l) );
-
- if (Tol_1D < Precision::Confusion()) Tol_1D = Precision::Confusion();
- if (Tol_2D < Precision::Confusion()) Tol_2D = Precision::Confusion();
- if (Tol_3D < Precision::Confusion()) Tol_3D = Precision::Confusion();
-
- Tol_Mass = Tol_3D;
- if ( iType == TopAbs_EDGE ) Tol_Mass = Tol_1D;
- else if ( iType == TopAbs_FACE ) Tol_Mass = Tol_2D;
-
- // Compute the ShapeWhat Mass
- for ( ; Exp_aWhat.More(); Exp_aWhat.Next() ) {
- if ( iType == TopAbs_EDGE ) BRepGProp::LinearProperties(Exp_aWhat.Current(), aProps);
- else if ( iType == TopAbs_FACE ) BRepGProp::SurfaceProperties(Exp_aWhat.Current(), aProps);
- else BRepGProp::VolumeProperties(Exp_aWhat.Current(), aProps);
- aWhat_Mass += aProps.Mass();
- }
-
- // Searching for the sub-shapes inside the ShapeWhere shape
- TopTools_MapOfShape map_aWhere;
- for ( Exp_aWhere.ReInit(); Exp_aWhere.More(); Exp_aWhere.Next() ) {
- if (!map_aWhere.Add(Exp_aWhere.Current()))
- continue; // skip repeated shape to avoid mass addition
- GetShapeProperties( Exp_aWhere.Current(), tab_aWhere, aPnt );
- for ( Exp_aWhat.ReInit(); Exp_aWhat.More(); Exp_aWhat.Next() ) {
- GetShapeProperties( Exp_aWhat.Current(), tab_aWhat, aPnt_aWhat );
- if ( fabs(tab_aWhat[3] - tab_aWhere[3]) <= Tol_Mass && aPnt_aWhat.Distance(aPnt) <= Tol_1D )
- isFound = true;
- else {
- if ( (tab_aWhat[3] - tab_aWhere[3]) > Tol_Mass ) {
- aPntShape = BRepBuilderAPI_MakeVertex( aPnt ).Shape();
- aVertex = TopoDS::Vertex( aPntShape );
- BRepExtrema_DistShapeShape aWhereDistance ( aVertex, Exp_aWhere.Current() );
- BRepExtrema_DistShapeShape aWhatDistance ( aVertex, Exp_aWhat.Current() );
- if ( fabs(aWhereDistance.Value() - aWhatDistance.Value()) <= Tol_1D )
- isFound = true;
- }
- }
- if ( isFound ) {
- aWhereIndex = aWhereIndices.FindIndex(Exp_aWhere.Current());
- aModifiedList.Append(aWhereIndex);
- aWhere_Mass += tab_aWhere[3];
- isFound = false;
- break;
- }
+ Handle(TColStd_HArray1OfInteger) aModifiedArray =
+ new TColStd_HArray1OfInteger (1, aModifiedList.Extent());
+ TopTools_ListIteratorOfListOfShape anIterModif (aModifiedList);
+ Standard_Integer imod;
+ Standard_Integer aShapeType = -1;
+
+ for (imod = 1; anIterModif.More(); anIterModif.Next(), imod++) {
+ const Standard_Integer anIndex =
+ aWhereIndices.FindIndex(anIterModif.Value());
+ const TopAbs_ShapeEnum aType = anIterModif.Value().ShapeType();
+
+ if (aShapeType == -1) {
+ // Initialization.
+ aShapeType = aType;
+ } else if (aShapeType != TopAbs_SHAPE && aShapeType != aType) {
+ // Different types.
+ aShapeType = TopAbs_SHAPE;
}
- if ( fabs( aWhat_Mass - aWhere_Mass ) <= Tol_Mass ) break;
- }
- if (aModifiedList.Extent() == 0) { // Not found any Results
- SetErrorCode(NOT_FOUND_ANY);
- return NULL;
+ aModifiedArray->SetValue(imod, anIndex);
}
- aModifiedArray = new TColStd_HArray1OfInteger (1, aModifiedList.Extent());
- TColStd_ListIteratorOfListOfInteger anIterModif (aModifiedList);
- for (Standard_Integer imod = 1; anIterModif.More(); anIterModif.Next(), imod++)
- aModifiedArray->SetValue(imod, anIterModif.Value());
-
//Add a new object
- aResult = GetEngine()->AddSubShape(theShapeWhere, aModifiedArray);
+ Handle(GEOM_Object) aResult =
+ GetEngine()->AddSubShape(theShapeWhere, aModifiedArray);
+
if (aResult.IsNull()) {
SetErrorCode("Error in algorithm: result found, but cannot be returned.");
return NULL;
}
- if (aModifiedArray->Length() > 1) {
+ const Standard_Boolean isSameType = (aShapeType != TopAbs_SHAPE);
+
+ if ((aModifiedArray->Length() > 1 && isSameType) ||
+ theShapeWhat->GetType() == GEOM_GROUP) {
//Set a GROUP type
aResult->SetType(GEOM_GROUP);
- //Set a sub shape type
+ //Set a sub-shape type
TopoDS_Shape aFirstFound = aWhereIndices.FindKey(aModifiedArray->Value(1));
TopAbs_ShapeEnum aShapeType = aFirstFound.ShapeType();
Handle(GEOM_Function) aFunction = aResult->GetFunction(1);
GEOM::TPythonDump(aFunction) << aResult << " = geompy.GetInPlace("
- << theShapeWhere << ", " << theShapeWhat << ")";
+ << theShapeWhere << ", " << theShapeWhat << ", False)";
SetErrorCode(OK);
+
return aResult;
}
//Fill array of indices
TopTools_IndexedMapOfShape aWhereIndices;
+
TopExp::MapShapes(aWhere, aWhereIndices);
// process shape
- TColStd_ListOfInteger aModifiedList;
- bool isFound = GetInPlaceOfShape(aWhereFunction, aWhereIndices, aWhat, aModifiedList);
+ TopTools_ListOfShape aModifiedList;
+ bool isFound = GEOMAlgo_GetInPlaceAPI::GetInPlaceByHistory
+ (aWhereFunction, aWhereIndices, aWhat, aModifiedList);
if (!isFound || aModifiedList.Extent() < 1) {
SetErrorCode("Error: No history found for the sought shape or its sub-shapes.");
return NULL;
}
- Handle(TColStd_HArray1OfInteger) aModifiedArray =
+ Handle(TColStd_HArray1OfInteger) aModifiedArray =
new TColStd_HArray1OfInteger (1, aModifiedList.Extent());
- TColStd_ListIteratorOfListOfInteger anIterModif (aModifiedList);
- for (Standard_Integer imod = 1; anIterModif.More(); anIterModif.Next(), imod++) {
- aModifiedArray->SetValue(imod, anIterModif.Value());
+ TopTools_ListIteratorOfListOfShape anIterModif (aModifiedList);
+ Standard_Integer imod;
+ Standard_Integer aShapeType = -1;
+
+ for (imod = 1; anIterModif.More(); anIterModif.Next(), imod++) {
+ const Standard_Integer anIndex =
+ aWhereIndices.FindIndex(anIterModif.Value());
+ const TopAbs_ShapeEnum aType = anIterModif.Value().ShapeType();
+
+ if (aShapeType == -1) {
+ // Initialization.
+ aShapeType = aType;
+ } else if (aShapeType != TopAbs_SHAPE && aShapeType != aType) {
+ // Different types.
+ aShapeType = TopAbs_SHAPE;
+ }
+
+ aModifiedArray->SetValue(imod, anIndex);
}
//Add a new object
return NULL;
}
- if (aModifiedArray->Length() > 1) {
+ const Standard_Boolean isSameType = (aShapeType != TopAbs_SHAPE);
+
+ if ((aModifiedArray->Length() > 1 && isSameType) ||
+ theShapeWhat->GetType() == GEOM_GROUP) {
//Set a GROUP type
aResult->SetType(GEOM_GROUP);
- //Set a sub shape type
+ //Set a sub-shape type
TopoDS_Shape aFirstFound = aWhereIndices.FindKey(aModifiedArray->Value(1));
TopAbs_ShapeEnum aShapeType = aFirstFound.ShapeType();
Handle(GEOM_Function) aFunction = aResult->GetFunction(1);
GEOM::TPythonDump(aFunction) << aResult << " = geompy.GetInPlaceByHistory("
- << theShapeWhere << ", " << theShapeWhat << ")";
+ << theShapeWhere << ", " << theShapeWhat << ")";
SetErrorCode(OK);
return aResult;
}
//=======================================================================
-//function : SortShapes
-//purpose :
-//=======================================================================
-void GEOMImpl_IShapesOperations::SortShapes(TopTools_ListOfShape& SL)
-{
- Standard_Integer MaxShapes = SL.Extent();
- TopTools_Array1OfShape aShapes (1,MaxShapes);
- TColStd_Array1OfInteger OrderInd(1,MaxShapes);
- TColStd_Array1OfReal MidXYZ (1,MaxShapes); //X,Y,Z;
- TColStd_Array1OfReal Length (1,MaxShapes); //X,Y,Z;
-
- // Computing of CentreOfMass
- Standard_Integer Index;
- GProp_GProps GPr;
- gp_Pnt GPoint;
- TopTools_ListIteratorOfListOfShape it(SL);
- for (Index=1; it.More(); Index++)
- {
- TopoDS_Shape S = it.Value();
- SL.Remove( it ); // == it.Next()
- aShapes(Index) = S;
- OrderInd.SetValue (Index, Index);
- if (S.ShapeType() == TopAbs_VERTEX)
- {
- GPoint = BRep_Tool::Pnt( TopoDS::Vertex( S ));
- Length.SetValue( Index, (Standard_Real) S.Orientation());
- }
- else
- {
- BRepGProp::LinearProperties (S, GPr);
- GPoint = GPr.CentreOfMass();
- Length.SetValue( Index, GPr.Mass() );
- }
- MidXYZ.SetValue(Index,
- GPoint.X()*999 + GPoint.Y()*99 + GPoint.Z()*0.9);
- //cout << Index << " L: " << Length(Index) << "CG: " << MidXYZ(Index) << endl;
- }
-
- // Sorting
- Standard_Integer aTemp;
- Standard_Boolean exchange, Sort = Standard_True;
- Standard_Real tol = Precision::Confusion();
- while (Sort)
- {
- Sort = Standard_False;
- for (Index=1; Index < MaxShapes; Index++)
- {
- exchange = Standard_False;
- Standard_Real dMidXYZ = MidXYZ(OrderInd(Index)) - MidXYZ(OrderInd(Index+1));
- Standard_Real dLength = Length(OrderInd(Index)) - Length(OrderInd(Index+1));
- if ( dMidXYZ >= tol ) {
-// cout << "MidXYZ: " << MidXYZ(OrderInd(Index))<< " > " <<MidXYZ(OrderInd(Index+1))
-// << " d: " << dMidXYZ << endl;
- exchange = Standard_True;
- }
- else if ( Abs(dMidXYZ) < tol && dLength >= tol ) {
-// cout << "Length: " << Length(OrderInd(Index))<< " > " <<Length(OrderInd(Index+1))
-// << " d: " << dLength << endl;
- exchange = Standard_True;
- }
- else if ( Abs(dMidXYZ) < tol && Abs(dLength) < tol &&
- aShapes(OrderInd(Index)).ShapeType() <= TopAbs_FACE) {
- // PAL17233
- // equal values possible on shapes such as two halves of a sphere and
- // a membrane inside the sphere
- Bnd_Box box1,box2;
- BRepBndLib::Add( aShapes( OrderInd(Index) ), box1 );
- if ( box1.IsVoid() ) continue;
- BRepBndLib::Add( aShapes( OrderInd(Index+1) ), box2 );
- Standard_Real dSquareExtent = box1.SquareExtent() - box2.SquareExtent();
- if ( dSquareExtent >= tol ) {
-// cout << "SquareExtent: " << box1.SquareExtent()<<" > "<<box2.SquareExtent() << endl;
- exchange = Standard_True;
- }
- else if ( Abs(dSquareExtent) < tol ) {
- Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, val1, val2;
- box1.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
- val1 = (aXmin+aXmax)*999 + (aYmin+aYmax)*99 + (aZmin+aZmax)*0.9;
- box2.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
- val2 = (aXmin+aXmax)*999 + (aYmin+aYmax)*99 + (aZmin+aZmax)*0.9;
- //exchange = val1 > val2;
- if ((val1 - val2) >= tol) {
- exchange = Standard_True;
- }
- //cout << "box: " << val1<<" > "<<val2 << endl;
- }
- }
-
- if (exchange)
- {
-// cout << "exchange " << Index << " & " << Index+1 << endl;
- aTemp = OrderInd(Index);
- OrderInd(Index) = OrderInd(Index+1);
- OrderInd(Index+1) = aTemp;
- Sort = Standard_True;
- }
- }
- }
-
- for (Index=1; Index <= MaxShapes; Index++)
- SL.Append( aShapes( OrderInd(Index) ));
-}
-
-//=======================================================================
-//function : CompsolidToCompound
+//function : GetInPlaceMap
//purpose :
//=======================================================================
-TopoDS_Shape GEOMImpl_IShapesOperations::CompsolidToCompound (const TopoDS_Shape& theCompsolid)
+void GEOMImpl_IShapesOperations::GetInPlaceMap (Handle(GEOM_Object) theShapeWhere,
+ Handle(GEOM_Object) theShapeWhat,
+ std::vector< std::vector< int > > & theResVec)
{
- if (theCompsolid.ShapeType() != TopAbs_COMPSOLID) {
- return theCompsolid;
- }
-
- TopoDS_Compound aCompound;
- BRep_Builder B;
- B.MakeCompound(aCompound);
-
- TopTools_MapOfShape mapShape;
- TopoDS_Iterator It (theCompsolid, Standard_True, Standard_True);
-
- for (; It.More(); It.Next()) {
- TopoDS_Shape aShape_i = It.Value();
- if (mapShape.Add(aShape_i)) {
- B.Add(aCompound, aShape_i);
- }
- }
-
- return aCompound;
-}
+ SetErrorCode(KO);
-//=======================================================================
-//function : CheckTriangulation
-//purpose :
-//=======================================================================
-bool GEOMImpl_IShapesOperations::CheckTriangulation (const TopoDS_Shape& aShape)
-{
- bool isTriangulation = true;
+ if (theShapeWhere.IsNull() || theShapeWhat.IsNull()) return;
- TopExp_Explorer exp (aShape, TopAbs_FACE);
- if (exp.More())
- {
- TopLoc_Location aTopLoc;
- Handle(Poly_Triangulation) aTRF;
- aTRF = BRep_Tool::Triangulation(TopoDS::Face(exp.Current()), aTopLoc);
- if (aTRF.IsNull()) {
- isTriangulation = false;
- }
- }
- else // no faces, try edges
- {
- TopExp_Explorer expe (aShape, TopAbs_EDGE);
- if (!expe.More()) {
- return false;
- }
- TopLoc_Location aLoc;
- Handle(Poly_Polygon3D) aPE = BRep_Tool::Polygon3D(TopoDS::Edge(expe.Current()), aLoc);
- if (aPE.IsNull()) {
- isTriangulation = false;
- }
- }
+ TopoDS_Shape aWhere = theShapeWhere->GetValue();
+ TopoDS_Shape aWhat = theShapeWhat->GetValue();
- if (!isTriangulation) {
- // calculate deflection
- Standard_Real aDeviationCoefficient = 0.001;
+ if (aWhere.IsNull() || aWhat.IsNull()) return;
- Bnd_Box B;
- BRepBndLib::Add(aShape, B);
- Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
- B.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
+ Handle(GEOM_Function) aWhereFunction = theShapeWhere->GetLastFunction();
+ if (aWhereFunction.IsNull()) return;
- Standard_Real dx = aXmax - aXmin, dy = aYmax - aYmin, dz = aZmax - aZmin;
- Standard_Real aDeflection = Max(Max(dx, dy), dz) * aDeviationCoefficient * 4;
- Standard_Real aHLRAngle = 0.349066;
+ bool isFound = GEOMAlgo_GetInPlaceAPI::GetInPlaceMap( aWhereFunction, aWhat, theResVec );
- BRepMesh_IncrementalMesh Inc (aShape, aDeflection, Standard_False, aHLRAngle);
- }
+ if ( isFound )
+ SetErrorCode(OK);
- return true;
-}
+ Handle(GEOM_Function) aFunction =
+ GEOM::GetCreatedLast(theShapeWhere,theShapeWhat)->GetLastFunction();
+
+ GEOM::TPythonDump(aFunction, /*append=*/true)
+ << "resultList = geompy.GetInPlaceMap( "
+ << theShapeWhere << ", "
+ << theShapeWhat << ")";
-#define MAX_TOLERANCE 1.e-7
+ return;
+}
//=======================================================================
//function : isSameEdge
double U11, U12, U21, U22;
Handle(Geom_Curve) C1 = BRep_Tool::Curve(theEdge1, U11, U12);
Handle(Geom_Curve) C2 = BRep_Tool::Curve(theEdge2, U21, U22);
- if(C1->DynamicType() == C2->DynamicType()) return true;
//Check that both edges has the same geometry
double range = U12-U11;
U = U11+range*2.0/3.0;
gp_Pnt P2 = C1->Value(U); //Compute a point on two thirds of the edge's length
+ C2 = new Geom_TrimmedCurve(C2, U21, U22);
+ // vsr 04/10/2018: 0023312 - As curve may be periodic, its parameters may be normalized
+ // so, we re-take them from trimmed curve
+ U21 = C2->FirstParameter();
+ U22 = C2->LastParameter();
+
if(!GeomLib_Tool::Parameter(C2, P1, MAX_TOLERANCE, U) || U < U21 || U > U22)
return false;
return true;
}
-#include <TopoDS_TShape.hxx>
//=======================================================================
//function : isSameFace
//purpose : Returns True if two faces coincide
//purpose :
//=======================================================================
Handle(GEOM_Object) GEOMImpl_IShapesOperations::GetSame(const Handle(GEOM_Object)& theShapeWhere,
- const Handle(GEOM_Object)& theShapeWhat)
+ const Handle(GEOM_Object)& theShapeWhat)
{
SetErrorCode(KO);
if (theShapeWhere.IsNull() || theShapeWhat.IsNull()) return NULL;
TopoDS_Shape aSubShape;
TopTools_MapOfShape aMap;
- switch(aWhat.ShapeType()) {
+ if (aWhat.ShapeType() == TopAbs_COMPOUND || aWhat.ShapeType() == TopAbs_COMPSOLID) {
+ TopoDS_Iterator It (aWhat, Standard_True, Standard_True);
+ if (It.More()) aWhat = It.Value();
+ It.Next();
+ if (It.More()) {
+ SetErrorCode("Compounds of two or more shapes are not allowed for aWhat argument");
+ return NULL;
+ }
+ }
+
+ switch (aWhat.ShapeType()) {
case TopAbs_VERTEX: {
- gp_Pnt P = BRep_Tool::Pnt(TopoDS::Vertex(aWhat));
- TopExp_Explorer E(aWhere, TopAbs_VERTEX);
- for(; E.More(); E.Next()) {
- if(!aMap.Add(E.Current())) continue;
- gp_Pnt P2 = BRep_Tool::Pnt(TopoDS::Vertex(E.Current()));
- if(P.Distance(P2) <= MAX_TOLERANCE) {
- isFound = true;
- aSubShape = E.Current();
- break;
- }
- }
+ aSubShape = getSameVertex(aWhere, TopoDS::Vertex(aWhat));
+ isFound = !aSubShape.IsNull();
break;
}
- case TopAbs_FACE: {
- TopoDS_Face aFace = TopoDS::Face(aWhat);
- TopExp_Explorer E(aWhere, TopAbs_FACE);
+ case TopAbs_EDGE: {
+ TopoDS_Edge anEdge = TopoDS::Edge(aWhat);
+ TopExp_Explorer E(aWhere, TopAbs_EDGE);
for(; E.More(); E.Next()) {
if(!aMap.Add(E.Current())) continue;
- if(isSameFace(aFace, TopoDS::Face(E.Current()))) {
+ if(isSameEdge(anEdge, TopoDS::Edge(E.Current()))) {
aSubShape = E.Current();
isFound = true;
break;
}
break;
}
- case TopAbs_EDGE: {
- TopoDS_Edge anEdge = TopoDS::Edge(aWhat);
- TopExp_Explorer E(aWhere, TopAbs_EDGE);
+ case TopAbs_FACE: {
+ TopoDS_Face aFace = TopoDS::Face(aWhat);
+ TopExp_Explorer E(aWhere, TopAbs_FACE);
for(; E.More(); E.Next()) {
if(!aMap.Add(E.Current())) continue;
- if(isSameEdge(anEdge, TopoDS::Edge(E.Current()))) {
+ if(isSameFace(aFace, TopoDS::Face(E.Current()))) {
aSubShape = E.Current();
isFound = true;
break;
return NULL;
}
- if(isFound) {
+ if (isFound) {
TopTools_IndexedMapOfShape anIndices;
TopExp::MapShapes(aWhere, anIndices);
if (anIndices.Contains(aSubShape))
anIndex = anIndices.FindIndex(aSubShape);
}
- if(anIndex < 0) return NULL;
+ if (anIndex < 0) return NULL;
Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
return aResult;
}
+
+
+//=======================================================================
+//function : GetSameIDs
+//purpose :
+//=======================================================================
+Handle(TColStd_HSequenceOfInteger) GEOMImpl_IShapesOperations::GetSameIDs
+ (const Handle(GEOM_Object)& theShapeWhere,
+ const Handle(GEOM_Object)& theShapeWhat)
+{
+ SetErrorCode(KO);
+ if (theShapeWhere.IsNull() || theShapeWhat.IsNull()) return NULL;
+
+ TopoDS_Shape aWhere = theShapeWhere->GetValue();
+ TopoDS_Shape aWhat = theShapeWhat->GetValue();
+
+ if (aWhere.IsNull() || aWhat.IsNull()) return NULL;
+
+ TopTools_ListOfShape listShape;
+ TopTools_MapOfShape aMap;
+
+ if (aWhat.ShapeType() == TopAbs_COMPOUND || aWhat.ShapeType() == TopAbs_COMPSOLID) {
+ TopoDS_Iterator It (aWhat, Standard_True, Standard_True);
+ if (It.More()) aWhat = It.Value();
+ It.Next();
+ if (It.More()) {
+ SetErrorCode("Compounds of two or more shapes are not allowed for aWhat argument");
+ return NULL;
+ }
+ }
+
+ switch (aWhat.ShapeType()) {
+ case TopAbs_VERTEX: {
+ gp_Pnt P = BRep_Tool::Pnt(TopoDS::Vertex(aWhat));
+ TopExp_Explorer E(aWhere, TopAbs_VERTEX);
+ for(; E.More(); E.Next()) {
+ if(!aMap.Add(E.Current())) continue;
+ gp_Pnt P2 = BRep_Tool::Pnt(TopoDS::Vertex(E.Current()));
+ if(P.Distance(P2) <= MAX_TOLERANCE) {
+ listShape.Append(E.Current());
+ }
+ }
+ break;
+ }
+ case TopAbs_EDGE: {
+ TopoDS_Edge anEdge = TopoDS::Edge(aWhat);
+ TopExp_Explorer E(aWhere, TopAbs_EDGE);
+ for(; E.More(); E.Next()) {
+ if(!aMap.Add(E.Current())) continue;
+ if(isSameEdge(anEdge, TopoDS::Edge(E.Current()))) {
+ listShape.Append(E.Current());
+ }
+ }
+ break;
+ }
+ case TopAbs_FACE: {
+ TopoDS_Face aFace = TopoDS::Face(aWhat);
+ TopExp_Explorer E(aWhere, TopAbs_FACE);
+ for(; E.More(); E.Next()) {
+ if(!aMap.Add(E.Current())) continue;
+ if(isSameFace(aFace, TopoDS::Face(E.Current()))) {
+ listShape.Append(E.Current());
+ }
+ }
+ break;
+ }
+ case TopAbs_SOLID: {
+ TopoDS_Solid aSolid = TopoDS::Solid(aWhat);
+ TopExp_Explorer E(aWhere, TopAbs_SOLID);
+ for(; E.More(); E.Next()) {
+ if(!aMap.Add(E.Current())) continue;
+ if(isSameSolid(aSolid, TopoDS::Solid(E.Current()))) {
+ listShape.Append(E.Current());
+ }
+ }
+ break;
+ }
+ default:
+ return NULL;
+ }
+
+ if ( !listShape.IsEmpty() ) {
+ TopTools_IndexedMapOfShape anIndices;
+ TopExp::MapShapes(aWhere, anIndices);
+ TopTools_ListIteratorOfListOfShape itSub (listShape);
+ Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger;
+ for (; itSub.More(); itSub.Next()) {
+ if (anIndices.Contains(itSub.Value()))
+ aSeq->Append(anIndices.FindIndex(itSub.Value()));
+ }
+ SetErrorCode(OK);
+ // The GetSameIDs() doesn't change object so no new function is required.
+ Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShapeWhere,theShapeWhat)->GetLastFunction();
+
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
+ // Make a Python command
+ GEOM::TPythonDump(aFunction, /*append=*/true)
+ << "listSameIDs = geompy.GetSameIDs("
+ << theShapeWhere << ", "
+ << theShapeWhat << ")";
+#endif // DUMP_SUBSHAPE_IDS
+ return aSeq;
+ } else {
+ SetErrorCode(NOT_FOUND_ANY);
+ return NULL;
+ }
+}
+
+//=======================================================================
+//function : ExtendEdge
+//purpose :
+//=======================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::ExtendEdge
+ (const Handle(GEOM_Object) &theEdge,
+ const Standard_Real theMin,
+ const Standard_Real theMax)
+{
+ SetErrorCode(KO);
+
+ if (theEdge.IsNull()) {
+ return NULL;
+ }
+
+ //Add a new Edge object
+ Handle(GEOM_Object) aResEdge = GetEngine()->AddObject(GEOM_EDGE);
+
+ //Add a new Vector function
+ Handle(GEOM_Function) aFunction =
+ aResEdge->AddFunction(GEOMImpl_ShapeDriver::GetID(), EDGE_UV);
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) {
+ return NULL;
+ }
+
+ GEOMImpl_IShapeExtend aCI (aFunction);
+
+ Handle(GEOM_Function) anEdge = theEdge->GetLastFunction();
+
+ if (anEdge.IsNull()) {
+ return NULL;
+ }
+
+ aCI.SetShape(anEdge);
+ aCI.SetUMin(theMin);
+ aCI.SetUMax(theMax);
+
+ //Compute the Edge value
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed");
+
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+
+ return NULL;
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump(aFunction)
+ << aResEdge << " = geompy.ExtendEdge("
+ << theEdge << ", " << theMin << ", " << theMax << ")";
+
+ SetErrorCode(OK);
+
+ return aResEdge;
+}
+
+//=======================================================================
+//function : ExtendFace
+//purpose :
+//=======================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::ExtendFace
+ (const Handle(GEOM_Object) &theFace,
+ const Standard_Real theUMin,
+ const Standard_Real theUMax,
+ const Standard_Real theVMin,
+ const Standard_Real theVMax)
+{
+ SetErrorCode(KO);
+
+ if (theFace.IsNull()) {
+ return NULL;
+ }
+
+ //Add a new Face object
+ Handle(GEOM_Object) aResFace = GetEngine()->AddObject(GEOM_FACE);
+
+ //Add a new Vector function
+ Handle(GEOM_Function) aFunction =
+ aResFace->AddFunction(GEOMImpl_ShapeDriver::GetID(), FACE_UV);
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) {
+ return NULL;
+ }
+
+ GEOMImpl_IShapeExtend aCI (aFunction);
+
+ Handle(GEOM_Function) aFace = theFace->GetLastFunction();
+
+ if (aFace.IsNull()) {
+ return NULL;
+ }
+
+ aCI.SetShape(aFace);
+ aCI.SetUMin(theUMin);
+ aCI.SetUMax(theUMax);
+ aCI.SetVMin(theVMin);
+ aCI.SetVMax(theVMax);
+
+ //Compute the Face value
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed");
+
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+
+ return NULL;
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump(aFunction)
+ << aResFace << " = geompy.ExtendFace("
+ << theFace << ", " << theUMin << ", " << theUMax << ", "
+ << theVMin << ", " << theVMax << ")";
+
+ SetErrorCode(OK);
+
+ return aResFace;
+}
+
+//=======================================================================
+//function : MakeSurfaceFromFace
+//purpose :
+//=======================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeSurfaceFromFace
+ (const Handle(GEOM_Object) &theFace)
+{
+ SetErrorCode(KO);
+
+ if (theFace.IsNull()) {
+ return NULL;
+ }
+
+ //Add a new Face object
+ Handle(GEOM_Object) aResFace = GetEngine()->AddObject(GEOM_FACE);
+
+ //Add a new Vector function
+ Handle(GEOM_Function) aFunction =
+ aResFace->AddFunction(GEOMImpl_ShapeDriver::GetID(), SURFACE_FROM_FACE);
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) {
+ return NULL;
+ }
+
+ GEOMImpl_IShapeExtend aCI (aFunction);
+
+ Handle(GEOM_Function) aFace = theFace->GetLastFunction();
+
+ if (aFace.IsNull()) {
+ return NULL;
+ }
+
+ aCI.SetShape(aFace);
+
+ //Compute the Face value
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed");
+
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+
+ return NULL;
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump(aFunction)
+ << aResFace << " = geompy.MakeSurfaceFromFace("
+ << theFace << ")";
+
+ SetErrorCode(OK);
+
+ return aResFace;
+}
