diff --git a/idl/GEOM_Gen.idl b/idl/GEOM_Gen.idl index 7907cde35..545c289c3 100644 --- a/idl/GEOM_Gen.idl +++ b/idl/GEOM_Gen.idl @@ -220,6 +220,29 @@ module GEOM CC_LE ///< Less then or equal to }; + /*! + * \brief Wire construction mode. Regulates the way gaps are closed. + * + * Is used in function GEOM_IShapesOperations.MakeWire() + */ + enum wire_build_mode + { + /*! Do not change curves, just enlarge wire tolerance to cover the gaps */ + WBM_FixTolerance, + + /*! + * Replace curves, neighbour to the gap, + * with BSplines, connecting in the middle of the gap + */ + WBM_Approximation, + + /*! + * Replace curves, neighbour to the gap, with new curves of the same + * type and close parameters, connecting in the middle of the gap + */ + WBM_KeepCurveType + }; + /*! * \brief Object creation parameters * @@ -2034,10 +2057,12 @@ module GEOM * \param theEdgesAndWires List of edge and/or wires. * \param theTolerance Maximum distance between vertices, that will be merged. * Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion()). + * \param theMode Mode of gaps filling. * \return New GEOM_Object, containing the created wire. */ GEOM_Object MakeWire (in ListOfGO theEdgesAndWires, - in double theTolerance); + in double theTolerance, + in wire_build_mode theMode); /*! * \brief Create a face on the given wire. diff --git a/src/BuildGUI/BuildGUI_WireDlg.cxx b/src/BuildGUI/BuildGUI_WireDlg.cxx index ced4dca26..cf3088d92 100644 --- a/src/BuildGUI/BuildGUI_WireDlg.cxx +++ b/src/BuildGUI/BuildGUI_WireDlg.cxx @@ -288,7 +288,9 @@ bool BuildGUI_WireDlg::execute (ObjectList& objects) for ( int i = 0; i < myEdgesAndWires.count(); i++ ) objlist[i] = myEdgesAndWires[i].copy(); - GEOM::GEOM_Object_var anObj = anOper->MakeWire(objlist.in(), GroupArgs->SpinBox_DX->value()); + GEOM::GEOM_Object_var anObj = anOper->MakeWire(objlist.in(), + GroupArgs->SpinBox_DX->value(), + GEOM::WBM_FixTolerance); if (!anObj->_is_nil()) objects.push_back(anObj._retn()); diff --git a/src/GEOMImpl/GEOMImpl_IShapes.hxx b/src/GEOMImpl/GEOMImpl_IShapes.hxx index 58f12fe63..78ded78b6 100644 --- a/src/GEOMImpl/GEOMImpl_IShapes.hxx +++ b/src/GEOMImpl/GEOMImpl_IShapes.hxx @@ -41,6 +41,7 @@ class GEOMImpl_IShapes SHAPE_ARG_INDICES = 5, // for Sub-shape SHAPE_ARG_TOLERANCE = 6, // linear tolerance (for Wire, Edge) SHAPE_ARG_ANGLE_TOL = 7, // angular tolerance (for Edge) + SHAPE_ARG_WIRE_MODE = 8, // gaps closing mode (for Wire) }; GEOMImpl_IShapes(Handle(GEOM_Function) theFunction): _func(theFunction) {} @@ -77,6 +78,11 @@ class GEOMImpl_IShapes Standard_Real GetTolerance() { return _func->GetReal(SHAPE_ARG_TOLERANCE); } + void SetWireMode(const Standard_Integer theValue) + { _func->SetInteger(SHAPE_ARG_WIRE_MODE, theValue); } + + Standard_Integer GetWireMode() { return _func->GetInteger(SHAPE_ARG_WIRE_MODE); } + void SetAngularTolerance(const Standard_Real theValue) { _func->SetReal(SHAPE_ARG_ANGLE_TOL, theValue); } diff --git a/src/GEOMImpl/GEOMImpl_IShapesOperations.cxx b/src/GEOMImpl/GEOMImpl_IShapesOperations.cxx index f56352eb7..65947e727 100644 --- a/src/GEOMImpl/GEOMImpl_IShapesOperations.cxx +++ b/src/GEOMImpl/GEOMImpl_IShapesOperations.cxx @@ -377,7 +377,8 @@ Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeEdgeWire //============================================================================= Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeWire (std::list theShapes, - const Standard_Real theTolerance) + const Standard_Real theTolerance, + const GEOMImpl_WireBuildMode theMode) { SetErrorCode(KO); @@ -394,6 +395,7 @@ Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeWire GEOMImpl_IShapes aCI (aFunction); aCI.SetTolerance(theTolerance); + aCI.SetWireMode(theMode); Handle(TColStd_HSequenceOfTransient) aShapesSeq = new TColStd_HSequenceOfTransient; @@ -424,7 +426,19 @@ Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeWire //Make a Python command GEOM::TPythonDump pd (aFunction); - pd << aWire << " = geompy.MakeWire(["; + pd << aWire; + switch (theMode) { + case GEOMImpl_WBM_FixTolerance: + pd << " = geompy.MakeWire(["; + break; + case GEOMImpl_WBM_Approximation: + pd << " = geompy.MakeWireWithMode(["; + break; + case GEOMImpl_WBM_KeepCurveType: + pd << " = geompy.MakeWireConstCurveType(["; + break; + default: ; + } // Shapes it = theShapes.begin(); @@ -434,7 +448,11 @@ Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeWire pd << ", " << (*it++); } } - pd << "], " << theTolerance << ")"; + pd << "], " << theTolerance; + if (theMode == GEOMImpl_WBM_Approximation) { + pd << ", GEOM.WBM_Approximation"; + } + pd << ")"; SetErrorCode(OK); return aWire; diff --git a/src/GEOMImpl/GEOMImpl_IShapesOperations.hxx b/src/GEOMImpl/GEOMImpl_IShapesOperations.hxx index 71ca26dc5..c22b34a25 100644 --- a/src/GEOMImpl/GEOMImpl_IShapesOperations.hxx +++ b/src/GEOMImpl/GEOMImpl_IShapesOperations.hxx @@ -48,6 +48,12 @@ class GEOM_Engine; class GEOM_Object; class TopoDS_Shape; +enum GEOMImpl_WireBuildMode { + GEOMImpl_WBM_FixTolerance = 1, + GEOMImpl_WBM_Approximation = 2, + GEOMImpl_WBM_KeepCurveType = 3 +}; + class GEOMImpl_IShapesOperations : public GEOM_IOperations { public: @@ -94,7 +100,8 @@ class GEOMImpl_IShapesOperations : public GEOM_IOperations const Standard_Real theAngularTolerance); Standard_EXPORT Handle(GEOM_Object) MakeWire (std::list theEdgesAndWires, - const Standard_Real theTolerance); + const Standard_Real theTolerance, + const GEOMImpl_WireBuildMode theMode = GEOMImpl_WBM_FixTolerance); Standard_EXPORT Handle(GEOM_Object) MakeFace (Handle(GEOM_Object) theWire, const bool isPlanarWanted); diff --git a/src/GEOMImpl/GEOMImpl_ShapeDriver.cxx b/src/GEOMImpl/GEOMImpl_ShapeDriver.cxx index 3d00b9ac7..b9e18d65e 100644 --- a/src/GEOMImpl/GEOMImpl_ShapeDriver.cxx +++ b/src/GEOMImpl/GEOMImpl_ShapeDriver.cxx @@ -22,6 +22,8 @@ #include +#include + #include #include #include @@ -436,7 +438,9 @@ Standard_Integer GEOMImpl_ShapeDriver::Execute(Handle(TFunction_Logbook)& log) c if (aTolerance < Precision::Confusion()) aTolerance = Precision::Confusion(); - aShape = MakeWireFromEdges(aShapes, aTolerance); + Standard_Integer aMode = aCI.GetWireMode(); + + aShape = MakeWireFromEdges(aShapes, aTolerance, (GEOMImpl_WireBuildMode)aMode); } else if (aType == FACE_WIRE) { // result may be a face or a compound of faces @@ -1088,7 +1092,8 @@ Standard_Integer GEOMImpl_ShapeDriver::Execute(Handle(TFunction_Logbook)& log) c } TopoDS_Wire GEOMImpl_ShapeDriver::MakeWireFromEdges(const Handle(TColStd_HSequenceOfTransient)& theEdgesFuncs, - const Standard_Real theTolerance) + const Standard_Real theTolerance, + const GEOMImpl_WireBuildMode theMode) { BRep_Builder B; @@ -1136,14 +1141,27 @@ TopoDS_Wire GEOMImpl_ShapeDriver::MakeWireFromEdges(const Handle(TColStd_HSequen } aFW->ClosedWireMode() = isClosed; aFW->FixConnected(theTolerance); + if (aFW->StatusConnected(ShapeExtend_FAIL)) { Standard_ConstructionError::Raise("Wire construction failed: cannot build connected wire"); } // IMP 0019766 - if (aFW->StatusConnected(ShapeExtend_DONE3)) { - // Confused with but not Analyzer.Precision(), set the same - aFW->SetPrecision(theTolerance); // bos #33377, prevent conversion of initial curves to BSplines + if (theMode == GEOMImpl_WBM_KeepCurveType) { +#if OCC_VERSION_LARGE > 0x07050305 + aFW->FixCurves(); + if (aFW->StatusCurves(ShapeExtend_FAIL)) { + Standard_ConstructionError::Raise("Wire construction failed: cannot rebuild curves through new points"); + } +#else + Standard_NotImplemented::Raise("Wire construction failed: option KeepCurveType is not supported by current OCCT version: please, use OCCT 7.5.3p6 or newer."); +#endif // OCC_VERSION_LARGE > 0x07050305 + } + else if (aFW->StatusConnected(ShapeExtend_DONE3)) { + if (theMode != GEOMImpl_WBM_Approximation) { + // Confused with but not Analyzer.Precision(), set the same + aFW->SetPrecision(theTolerance); + } aFW->FixGapsByRangesMode() = Standard_True; if (aFW->FixGaps3d()) { Handle(ShapeExtend_WireData) sbwd = aFW->WireData(); @@ -1906,6 +1924,7 @@ GetCreationInformation(std::string& theOperationName, theOperationName = "WIRE"; AddParam( theParams, "Wires/edges", aCI.GetShapes() ); AddParam( theParams, "Tolerance", aCI.GetTolerance() ); + AddParam( theParams, "Mode", aCI.GetWireMode() ); break; case FACE_WIRE: theOperationName = "FACE"; diff --git a/src/GEOMImpl/GEOMImpl_ShapeDriver.hxx b/src/GEOMImpl/GEOMImpl_ShapeDriver.hxx index 0194b880c..029b090f6 100644 --- a/src/GEOMImpl/GEOMImpl_ShapeDriver.hxx +++ b/src/GEOMImpl/GEOMImpl_ShapeDriver.hxx @@ -31,6 +31,8 @@ #include #include +#include "GEOMImpl_IShapesOperations.hxx" + #include class TopoDS_Face; @@ -56,7 +58,8 @@ public: Standard_EXPORT static TopoDS_Wire MakeWireFromEdges (const Handle(TColStd_HSequenceOfTransient)& theEdgesFuncs, - const Standard_Real theTolerance); + const Standard_Real theTolerance, + const GEOMImpl_WireBuildMode theMode = GEOMImpl_WBM_FixTolerance); Standard_EXPORT virtual bool GetCreationInformation(std::string& theOperationName, std::vector& params); diff --git a/src/GEOM_I/GEOM_IShapesOperations_i.cc b/src/GEOM_I/GEOM_IShapesOperations_i.cc index 97d5a5101..8fa0c9d56 100644 --- a/src/GEOM_I/GEOM_IShapesOperations_i.cc +++ b/src/GEOM_I/GEOM_IShapesOperations_i.cc @@ -186,7 +186,8 @@ GEOM::GEOM_Object_ptr GEOM_IShapesOperations_i::MakeEdgeWire //============================================================================= GEOM::GEOM_Object_ptr GEOM_IShapesOperations_i::MakeWire (const GEOM::ListOfGO& theEdgesAndWires, - const CORBA::Double theTolerance) + const CORBA::Double theTolerance, + const GEOM::wire_build_mode theMode) { GEOM::GEOM_Object_var aGEOMObject; @@ -204,9 +205,22 @@ GEOM::GEOM_Object_ptr GEOM_IShapesOperations_i::MakeWire aShapes.push_back(aSh); } + // Mode of gaps closing + GEOMImpl_WireBuildMode aMode = GEOMImpl_WBM_FixTolerance; + switch (theMode) { + case GEOM::WBM_Approximation: + aMode = GEOMImpl_WBM_Approximation; + break; + case GEOM::WBM_KeepCurveType: + aMode = GEOMImpl_WBM_KeepCurveType; + break; + default: + break; + } + // Make Solid Handle(::GEOM_Object) anObject = - GetOperations()->MakeWire(aShapes, theTolerance); + GetOperations()->MakeWire(aShapes, theTolerance, aMode); if (!GetOperations()->IsDone() || anObject.IsNull()) return aGEOMObject._retn(); diff --git a/src/GEOM_I/GEOM_IShapesOperations_i.hh b/src/GEOM_I/GEOM_IShapesOperations_i.hh index d01cf1d4b..b0ce1e768 100644 --- a/src/GEOM_I/GEOM_IShapesOperations_i.hh +++ b/src/GEOM_I/GEOM_IShapesOperations_i.hh @@ -56,7 +56,8 @@ class GEOM_I_EXPORT GEOM_IShapesOperations_i : const CORBA::Double theAngularTolerance); GEOM::GEOM_Object_ptr MakeWire (const GEOM::ListOfGO& theEdgesAndWires, - const CORBA::Double theTolerance); + const CORBA::Double theTolerance, + const GEOM::wire_build_mode theMode); GEOM::GEOM_Object_ptr MakeFace (GEOM::GEOM_Object_ptr theWire, CORBA::Boolean isPlanarWanted); diff --git a/src/GEOM_I_Superv/GEOM_Superv_i.cc b/src/GEOM_I_Superv/GEOM_Superv_i.cc index 974d8c3a9..d11ae492c 100644 --- a/src/GEOM_I_Superv/GEOM_Superv_i.cc +++ b/src/GEOM_I_Superv/GEOM_Superv_i.cc @@ -2153,7 +2153,7 @@ GEOM::GEOM_Object_ptr GEOM_Superv_i::MakeWire (GEOM::GEOM_List_ptr theEdgesAndWi if (GEOM_List_i* aListImplEW = dynamic_cast*>(GetServant(theEdgesAndWires, myPOA).in())) { getShapesOp(); - GEOM::GEOM_Object_ptr anObj = myShapesOp->MakeWire(aListImplEW->GetList(), theTolerance); + GEOM::GEOM_Object_ptr anObj = myShapesOp->MakeWire(aListImplEW->GetList(), theTolerance, GEOM::WBM_FixTolerance); endService( " GEOM_Superv_i::MakeWire" ); return anObj; } diff --git a/src/GEOM_SWIG/geomBuilder.py b/src/GEOM_SWIG/geomBuilder.py index a7f96b029..7caf93ca0 100644 --- a/src/GEOM_SWIG/geomBuilder.py +++ b/src/GEOM_SWIG/geomBuilder.py @@ -4717,6 +4717,8 @@ class geomBuilder(GEOM._objref_GEOM_Gen): return anObj ## Create a wire from the set of edges and wires. + # To close a gap, enlarges wire tolerance. + # # @param theEdgesAndWires List of edges and/or wires. # @param theTolerance Maximum distance between vertices, that will be merged. # Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion()) @@ -4731,6 +4733,7 @@ class geomBuilder(GEOM._objref_GEOM_Gen): def MakeWire(self, theEdgesAndWires, theTolerance = 1e-07, theName=None): """ Create a wire from the set of edges and wires. + To close a gap, enlarges wire tolerance. Parameters: theEdgesAndWires List of edges and/or wires. @@ -4744,11 +4747,92 @@ class geomBuilder(GEOM._objref_GEOM_Gen): New GEOM.GEOM_Object, containing the created wire. """ # Example: see GEOM_TestAll.py - anObj = self.ShapesOp.MakeWire(theEdgesAndWires, theTolerance) + anObj = self.ShapesOp.MakeWire(theEdgesAndWires, theTolerance, GEOM.WBM_FixTolerance) RaiseIfFailed("MakeWire", self.ShapesOp) self._autoPublish(anObj, theName, "wire") return anObj + ## Create a wire from the set of edges and wires. + # To close a gap, replaces curves, neighbour to the gap, with new curves + # of the same type and close parameters, connecting in the middle of the gap. + # + # @param theEdgesAndWires List of edges and/or wires. + # @param theTolerance Maximum distance between vertices, that will be merged. + # Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion()) + # @param theName Object name; when specified, this parameter is used + # for result publication in the study. Otherwise, if automatic + # publication is switched on, default value is used for result name. + # + # @return New GEOM.GEOM_Object, containing the created wire. + # + # @ref tui_creation_wire "Example" + @ManageTransactions("ShapesOp") + def MakeWireConstCurveType(self, theEdgesAndWires, theTolerance = 1e-07, theName=None): + """ + Create a wire from the set of edges and wires. + To close a gap, replaces curves, neighbour to the gap, with new curves + of the same type and close parameters, connecting in the middle of the gap. + + Parameters: + theEdgesAndWires List of edges and/or wires. + theTolerance Maximum distance between vertices, that will be merged. + Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion()). + theName Object name; when specified, this parameter is used + for result publication in the study. Otherwise, if automatic + publication is switched on, default value is used for result name. + + Returns: + New GEOM.GEOM_Object, containing the created wire. + """ + # Example: see GEOM_TestAll.py + anObj = self.ShapesOp.MakeWire(theEdgesAndWires, theTolerance, GEOM.WBM_KeepCurveType) + RaiseIfFailed("MakeWireConstCurveType", self.ShapesOp) + self._autoPublish(anObj, theName, "wire") + return anObj + + ## Create a wire from the set of edges and wires. + # Possible gaps are closed according to theMode. + # + # @param theEdgesAndWires List of edges and/or wires. + # @param theTolerance Maximum distance between vertices, that will be merged. + # Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion()) + # @param theMode GEOM.wire_build_mode Mode of gaps closing. + # Possible values are GEOM.WBM_FixTolerance, GEOM.WBM_KeepCurveType + # and GEOM.WBM_Approximation. + # @param theName Object name; when specified, this parameter is used + # for result publication in the study. Otherwise, if automatic + # publication is switched on, default value is used for result name. + # + # @return New GEOM.GEOM_Object, containing the created wire. + # + # @ref tui_creation_wire "Example" + @ManageTransactions("ShapesOp") + def MakeWireWithMode(self, theEdgesAndWires, theTolerance = 1e-07, + theMode = GEOM.WBM_Approximation, theName=None): + """ + Create a wire from the set of edges and wires. + Possible gaps are closed according to theMode. + + Parameters: + theEdgesAndWires List of edges and/or wires. + theTolerance Maximum distance between vertices, that will be merged. + Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion()). + theMode GEOM.wire_build_mode Mode of gaps closing. + Possible values are GEOM.WBM_FixTolerance, GEOM.WBM_KeepCurveType + and GEOM.WBM_Approximation. + theName Object name; when specified, this parameter is used + for result publication in the study. Otherwise, if automatic + publication is switched on, default value is used for result name. + + Returns: + New GEOM.GEOM_Object, containing the created wire. + """ + # Example: see GEOM_TestAll.py + anObj = self.ShapesOp.MakeWire(theEdgesAndWires, theTolerance, theMode) + RaiseIfFailed("MakeWireWithMode", self.ShapesOp) + self._autoPublish(anObj, theName, "wire") + return anObj + ## Create a face on the given wire. # @param theWire closed Wire or Edge to build the face on. # @param isPlanarWanted If TRUE, the algorithm tries to build a planar face. diff --git a/test/test_wire_modes.py b/test/test_wire_modes.py new file mode 100644 index 000000000..d5da080df --- /dev/null +++ b/test/test_wire_modes.py @@ -0,0 +1,138 @@ +# -*- coding: iso-8859-1 -*- +# Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE +# +# 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. +# +# 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 +# + +import salome +salome.salome_init() + +import GEOM +from salome.geom import geomBuilder +import math +geompy = geomBuilder.New() + +O = geompy.MakeVertex(0, 0, 0) +OX = geompy.MakeVectorDXDYDZ(1, 0, 0) +OY = geompy.MakeVectorDXDYDZ(0, 1, 0) +OZ = geompy.MakeVectorDXDYDZ(0, 0, 1) + +Vertex_1 = geompy.MakeVertex(30, 70, 0) +Vertex_2 = geompy.MakeVertex(100, 0, 0) +Vertex_3 = geompy.MakeVertex(100, 70, 0) +Vertex_4 = geompy.MakeVertex(0, 70, 0) +Vertex_5 = geompy.MakeVertex(60, 60, 0) +Vertex_6 = geompy.MakeVertex(10, 50, 0) +Vertex_7 = geompy.MakeVertex(20, 0, 0) +Vertex_8 = geompy.MakeVertex(15, 80, 0) +Vertex_9 = geompy.MakeVertex(35, 60, 0) +Vertex_10 = geompy.MakeVertex(-20, 80, 0) +Vertex_11 = geompy.MakeVertex(10, -10, 0) +Vertex_12 = geompy.MakeVertex(10, 20, 0) +Vertex_13 = geompy.MakeVertex(-10, 30, 0) +Vertex_14 = geompy.MakeVertex(-20, 0, 0) +Vertex_15 = geompy.MakeVertex(-10, -10, 0) + +# Linear segments +Curve_1 = geompy.MakePolyline([O, Vertex_2, Vertex_3, Vertex_4], True) + +# Circles +Circle_1 = geompy.MakeCircle(Vertex_3, None, 10) +Circle_2 = geompy.MakeCircle(Vertex_5, None, 15) + +# Ellipses +geomObj_1 = geompy.MakeEllipse(O, None, 30, 10) +geomObj_2 = geompy.MakeRotation(geomObj_1, OZ, 45*math.pi/180.0) +Translation_1 = geompy.MakeTranslation(geomObj_2, 100, 0, 0) +geomObj_3 = geompy.MakeEllipse(None, None, 20, 10) +geomObj_4 = geompy.MakeRotation(geomObj_3, OZ, 90*math.pi/180.0) +Translation_2 = geompy.MakeTranslation(geomObj_4, 50, 10, 0) + +# B-Spline curve +Curve_2 = geompy.MakeInterpol([Vertex_1, Vertex_6, Vertex_10, Vertex_8], True, False) + +# Bezier curve +Curve_4 = geompy.MakeBezier([Vertex_7, Vertex_12, Vertex_13, Vertex_14, Vertex_15, Vertex_11], True) + +# Partition +Partition_1 = geompy.MakePartition([Circle_1, Circle_2, Curve_1, Curve_2, Translation_1, Translation_2, Curve_4], [], [], [], geompy.ShapeType["EDGE"], 0, [], 0) + +[Edge_1,Edge_2,Edge_3,Edge_4,Edge_5,Edge_6,Edge_7,Edge_8,Edge_9,Edge_10,Edge_11,Edge_12,Edge_13,Edge_14,Edge_15,Edge_16,Edge_17,Edge_18,Edge_19,Edge_20,Edge_21,Edge_22,Edge_23,Edge_24,Edge_25,Edge_26,Edge_27,Edge_28,Edge_29,Edge_30,Edge_31,Edge_32] = geompy.ExtractShapes(Partition_1, geompy.ShapeType["FLAT"], True) + +# FuseCollinearEdges +Wire_1 = geompy.MakeWire([Edge_16, Edge_20], 1e-07) +Wire_2 = geompy.MakeWire([Edge_30, Edge_32], 1e-07) +Wire_3 = geompy.MakeWire([Edge_24, Edge_31], 1e-07) +Wire_4 = geompy.MakeWire([Edge_11, Edge_15], 1e-07) + +FuseEdges_1 = geompy.FuseCollinearEdgesWithinWire(Wire_1, []) +[Edge_33] = geompy.ExtractShapes(FuseEdges_1, geompy.ShapeType["EDGE"], True) +FuseEdges_2 = geompy.FuseCollinearEdgesWithinWire(Wire_2, []) +[Edge_34] = geompy.ExtractShapes(FuseEdges_2, geompy.ShapeType["EDGE"], True) +FuseEdges_3 = geompy.FuseCollinearEdgesWithinWire(Wire_3, []) +[Edge_35] = geompy.ExtractShapes(FuseEdges_3, geompy.ShapeType["EDGE"], True) +FuseEdges_4 = geompy.FuseCollinearEdgesWithinWire(Wire_4, []) +[Edge_36] = geompy.ExtractShapes(FuseEdges_4, geompy.ShapeType["EDGE"], True) + +# Make gaps +Translation_3 = geompy.MakeTranslation(Edge_2, -1, -1, 0) +Translation_4 = geompy.MakeTranslation(Edge_5, -1, 1, 0) +Translation_5 = geompy.MakeTranslation(Edge_18, 0, 1, 0) +Translation_6 = geompy.MakeTranslation(Edge_34, 1, 1, 0) +Translation_7 = geompy.MakeTranslation(Edge_35, 1, -1, 0) +Translation_8 = geompy.MakeTranslation(Edge_13, 0, -1, 0) + +Translation_9 = geompy.MakeTranslation(Edge_7, 1, 1, 0) +Translation_10 = geompy.MakeTranslation(Edge_9, 1, -1, 0) +Translation_11 = geompy.MakeTranslation(Edge_33, 0, -1, 0) +Translation_12 = geompy.MakeTranslation(Edge_25, -1, -1, 0) +Translation_13 = geompy.MakeTranslation(Edge_23, -1, 1, 0) +Translation_14 = geompy.MakeTranslation(Edge_36, 0, 1, 0) + +# Make wires + +# a. Old implementation (FixTolerance) +Wire_5 = geompy.MakeWire([Translation_3, Translation_4, Translation_5, Translation_6, Translation_7, Translation_8, Edge_3, Edge_10, Edge_12, Edge_19, Edge_21, Edge_28], 3, 'Wire_5') + +Wire_6 = geompy.MakeWire([Translation_9, Translation_10, Translation_11, Translation_12, Translation_13, Translation_14, Edge_3, Edge_10, Edge_12, Edge_19, Edge_21, Edge_28], 3, 'Wire_6') + +# b. New implementation (ConstCurveType) +Wire_7 = geompy.MakeWireConstCurveType([Translation_3, Translation_4, Translation_5, Translation_6, Translation_7, Translation_8, Edge_3, Edge_10, Edge_12, Edge_19, Edge_21, Edge_28], 3, 'Wire_7') + +Wire_8 = geompy.MakeWireConstCurveType([Translation_9, Translation_10, Translation_11, Translation_12, Translation_13, Translation_14, Edge_3, Edge_10, Edge_12, Edge_19, Edge_21, Edge_28], 3, 'Wire_8') + +# c. Approximation mode (in case of need canonical curves are approximated with b-splines) +Wire_9 = geompy.MakeWireWithMode([Translation_3, Translation_4, Translation_5, Translation_6, Translation_7, Translation_8, Edge_3, Edge_10, Edge_12, Edge_19, Edge_21, Edge_28], 3, GEOM.WBM_Approximation, 'Wire_9') + +Wire_10 = geompy.MakeWireWithMode([Translation_9, Translation_10, Translation_11, Translation_12, Translation_13, Translation_14, Edge_3, Edge_10, Edge_12, Edge_19, Edge_21, Edge_28], 3, GEOM.WBM_Approximation, 'Wire_10') + +### check wire length +Length5 = geompy.BasicProperties( Wire_5 )[0] +Length6 = geompy.BasicProperties( Wire_6 )[0] +Length7 = geompy.BasicProperties( Wire_7 )[0] +Length8 = geompy.BasicProperties( Wire_8 )[0] +Length9 = geompy.BasicProperties( Wire_9 )[0] +Length10 = geompy.BasicProperties( Wire_10 )[0] + +assert(abs(Length5 - 530.130817) < 1e-05) +assert(abs(Length6 - 415.467625) < 1e-05) +assert(abs(Length7 - 534.130817) < 1e-05) +assert(abs(Length8 - 411.467625) < 1e-05) + +# Here we have a problem with Approximation mode: "arcs" of bezier curve are wrongly treated +#assert(math.abs(Length9 - ) < 1e-05) +#assert(math.abs(Length10 - ) < 1e-05) diff --git a/test/tests.set b/test/tests.set index defc2286c..f2979e12d 100644 --- a/test/tests.set +++ b/test/tests.set @@ -32,3 +32,9 @@ IF(${OpenCASCADE_VERSION}.${OpenCASCADE_SP_VERSION} VERSION_GREATER "7.5.3.3") test_proximity_face_face.py ) ENDIF() + +IF(${OpenCASCADE_VERSION}.${OpenCASCADE_SP_VERSION} VERSION_GREATER "7.5.3.5") + LIST(APPEND ALL_TESTS + test_wire_modes.py + ) +ENDIF()