diff --git a/lib/windows/debug/oc.dll b/lib/windows/debug/oc.dll index 8e98ccfc..fb0f75af 100755 Binary files a/lib/windows/debug/oc.dll and b/lib/windows/debug/oc.dll differ diff --git a/lib/windows/debug/oc.pdb b/lib/windows/debug/oc.pdb index 24fe57be..e11139f6 100755 Binary files a/lib/windows/debug/oc.pdb and b/lib/windows/debug/oc.pdb differ diff --git a/oc.asd b/oc.asd index c26ca6f3..28968666 100755 --- a/oc.asd +++ b/oc.asd @@ -157,6 +157,8 @@ (:file "src/cpnts/geom-adaptor-curve") (:file "src/cpnts/cpnts-uniform-deflection") + (:file "src/shape-fix/shape-fix-wire") + (:file "src/xscontrol/xscontrol-reader") (:file "src/bnd/bnd-box") diff --git a/src/brep-mesh/brep-mesh-incremental-mesh.lisp b/src/brep-mesh/brep-mesh-incremental-mesh.lisp index e2e4363e..53654e36 100755 --- a/src/brep-mesh/brep-mesh-incremental-mesh.lisp +++ b/src/brep-mesh/brep-mesh-incremental-mesh.lisp @@ -1,27 +1,57 @@ (in-package :oc) (defmethod initialize-instance :after ((obj brep-mesh-incremental-mesh) &rest initargs - &key S D (Relative nil Relative-present-p) Ang &allow-other-keys) + &key theShape theLinDeflection + (isRelative nil isRelative-present-p) + theAngDeflection (isInParallel nil isInParallel-present-p) + (adaptiveMin nil adaptiveMin-present-p) + &allow-other-keys) (declare (ignore initargs)) (setf (ff-pointer obj) - (cond ((null S) (_wrap_new_BRepMesh_IncrementalMesh__SWIG_0)) - ((and (typep S 'topods-shape) - (typep D 'double-float) - (null Relative-present-p) - (null Ang)) - (_wrap_new_BRepMesh_IncrementalMesh__SWIG_3 (ff-pointer S) D)) + (cond ((null theShape) (_wrap_new_BRepMesh_IncrementalMesh__SWIG_0)) - ((and (typep S 'topods-shape) - (typep D 'double-float) - (null Ang) - Relative-present-p) - (_wrap_new_BRepMesh_IncrementalMesh__SWIG_2 (ff-pointer S) D Relative)) + ((and (typep theShape 'topods-shape) + (typep theLinDeflection 'double-float) + (null isRelative-present-p) + (null theAngDeflection) + (null isInParallel-present-p) + (null adaptiveMin-present-p)) + (_wrap_new_BRepMesh_IncrementalMesh__SWIG_5 (ff-pointer theShape) theLinDeflection)) - ((and (typep S 'topods-shape) - (typep D 'double-float) - (typep Ang 'double-float) - relative-present-p) - (_wrap_new_BrepMesh_IncrementalMesh__SWIG_1 (ff-pointer S) D Relative Ang)) + ((and (typep theShape 'topods-shape) + (typep theLinDeflection 'double-float) + isRelative-present-p + (null theAngDeflection) + (null isInParallel-present-p) + (null adaptiveMin-present-p)) + (_wrap_new_BRepMesh_IncrementalMesh__SWIG_4 (ff-pointer theShape) theLinDeflection isRelative)) + + ((and (typep theShape 'topods-shape) + (typep theLinDeflection 'double-float) + isRelative-present-p + (typep theAngDeflection 'double-float) + (null isInParallel-present-p) + (null adaptiveMin-present-p)) + (_wrap_new_BRepMesh_IncrementalMesh__SWIG_3 + (ff-pointer theShape) theLinDeflection isRelative theAngDeflection)) + + ((and (typep theShape 'topods-shape) + (typep theLinDeflection 'double-float) + isRelative-present-p + (typep theAngDeflection 'double-float) + isInParallel-present-p + (null adaptiveMin-present-p)) + (_wrap_new_BRepMesh_IncrementalMesh__SWIG_2 + (ff-pointer theShape) theLinDeflection isRelative theAngDeflection isInParallel)) + + ((and (typep theShape 'topods-shape) + (typep theLinDeflection 'double-float) + isRelative-present-p + (typep theAngDeflection 'double-float) + isInParallel-present-p + adaptiveMin-present-p) + (_wrap_new_BRepMesh_IncrementalMesh__SWIG_1 + (ff-pointer theShape) theLinDeflection isRelative theAngDeflection isInParallel adaptiveMin)) (t (error "Invalid arguments to initialize-instance of BRepMesh_IncrementalMesh.")))) (oc:finalize obj) diff --git a/src/classes.lisp b/src/classes.lisp index bdac985a..aac929c3 100755 --- a/src/classes.lisp +++ b/src/classes.lisp @@ -274,6 +274,11 @@ ;; +(defclass shape-fix-root () ()) +(defclass shape-fix-wire (shape-fix-root ff-pointer-mixin) ()) + +;; + (defclass xscontrol-reader (ff-pointer-mixin) ()) ;; diff --git a/src/collections/tcol.i b/src/collections/tcol.i index d4c0ebab..998b9002 100755 --- a/src/collections/tcol.i +++ b/src/collections/tcol.i @@ -111,6 +111,15 @@ class TColgp_Array1OfPnt { void Delete() { self->~TColgp_Array1OfPnt(); } + void GetPoint(const Standard_Integer Index, + Standard_Real& x, + Standard_Real& y, + Standard_Real& z) { + gp_Pnt result = (self)->Value(Index); + x = result.X(); + y = result.Y(); + z = result.Z(); + } } %{ #include diff --git a/src/finalizations.lisp b/src/finalizations.lisp index 86f4e5b1..49e36307 100644 --- a/src/finalizations.lisp +++ b/src/finalizations.lisp @@ -554,3 +554,6 @@ (defmethod foreign-free-fn ((object top-tools-list-of-shape)) #'_wrap_TopTools_ListOfShape_Delete) + +(defmethod foreign-free-fn ((object shape-fix-wire)) + #'_wrap_ShapeFix_Wire_Delete) diff --git a/src/gc/gc-make-arc-of-circle.lisp b/src/gc/gc-make-arc-of-circle.lisp index f91536f3..63ba83a9 100755 --- a/src/gc/gc-make-arc-of-circle.lisp +++ b/src/gc/gc-make-arc-of-circle.lisp @@ -1,15 +1,16 @@ (in-package :oc) (defmethod initialize-instance :after ((obj gc-make-arc-of-circle) &rest initargs - &key P1 P2 Circ Sense P3 &allow-other-keys) + &key P1 P2 Circ (Sense nil Sense-supplied-p) + P3 &allow-other-keys) (declare (ignore initargs)) (assert (gp:pnt-p P1)) (assert (gp:pnt-p P2)) (setf (ff-pointer obj) - (cond ((and Circ Sense) + (cond ((and Circ Sense-supplied-p) (assert (gp:circ-p Circ)) (assert (typep Sense 'boolean)) - (_wrap_new_GC_MakeArcOfCircle__SWIG_1 Circ (ptr P1) (ptr P2) Sense)) + (_wrap_new_GC_MakeArcOfCircle__SWIG_1 (ptr Circ) (ptr P1) (ptr P2) Sense)) (P3 (assert (gp:pnt-p P3)) (_wrap_new_GC_MakeArcOfCircle__SWIG_0 (ptr P1) (ptr P2) (ptr P3))) diff --git a/src/oc.i b/src/oc.i index 41c4e452..b2b35885 100755 --- a/src/oc.i +++ b/src/oc.i @@ -219,10 +219,16 @@ class BRepMesh_IncrementalMesh : public BRepMesh_DiscretRoot { public: BRepMesh_IncrementalMesh(); - BRepMesh_IncrementalMesh(const TopoDS_Shape& S,const Standard_Real D, + BRepMesh_IncrementalMesh(const TopoDS_Shape& theShape, + const Standard_Real theLinDeflection, + const Standard_Boolean isRelative = Standard_False, + const Standard_Real theAngDeflection = 0.5, + const Standard_Boolean isInParallel = Standard_False, + const Standard_Boolean adaptiveMin = Standard_False); + /* BRepMesh_IncrementalMesh(const TopoDS_Shape& S,const Standard_Real D, const Standard_Boolean Relatif = Standard_False, const Standard_Real Ang = 0.5); - + */ void Perform(); // void Update(const TopoDS_Shape& S) ; Standard_Boolean IsModified() const; diff --git a/src/oc.lisp b/src/oc.lisp index bf946883..34fa2dc4 100644 --- a/src/oc.lisp +++ b/src/oc.lisp @@ -5367,6 +5367,13 @@ (cffi:defcfun ("_wrap_TColgp_Array1OfPnt_Delete" _wrap_TColgp_Array1OfPnt_Delete) :void (self :pointer)) +(cffi:defcfun ("_wrap_TColgp_Array1OfPnt_GetPoint" _wrap_TColgp_Array1OfPnt_GetPoint) :void + (self :pointer) + (Index :int) + (x :pointer) + (y :pointer) + (z :pointer)) + (cffi:defcfun ("_wrap_new_TColgp_Array2OfPnt" _wrap_new_TColgp_Array2OfPnt) :pointer (theRowLower :int) (theRowUpper :int) @@ -9886,63 +9893,139 @@ (cffi:defcfun ("_wrap_delete_IGESControl_Controller" _wrap_delete_IGESControl_Controller) :void (self :pointer)) -(cffi:defcfun ("_wrap_ShapeFix_Root_SetPrecision" _wrap_ShapeFix_Root_SetPrecision) :void - (self :pointer) +(cffi:defcfun ("_wrap_ShapeFix_SameParameter__SWIG_0" _wrap_ShapeFix_SameParameter__SWIG_0) :bool + (shape :pointer) + (enforce :bool)) + +(cffi:defcfun ("_wrap_ShapeFix_SameParameter__SWIG_1" _wrap_ShapeFix_SameParameter__SWIG_1) :bool + (shape :pointer) + (enforce :bool) (preci :double)) -(cffi:defcfun ("_wrap_ShapeFix_Root_Precision" _wrap_ShapeFix_Root_Precision) :double - (self :pointer)) +(cffi:defcfun ("_wrap_ShapeFix_SameParameter__SWIG_2" _wrap_ShapeFix_SameParameter__SWIG_2) :bool + (shape :pointer) + (enforce :bool) + (preci :double) + (theProgress :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_SameParameter__SWIG_3" _wrap_ShapeFix_SameParameter__SWIG_3) :bool + (shape :pointer) + (enforce :bool) + (preci :double) + (theProgress :pointer) + (theMsgReg :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_EncodeRegularity__SWIG_0" _wrap_ShapeFix_EncodeRegularity__SWIG_0) :void + (shape :pointer) + (tolang :double)) + +(cffi:defcfun ("_wrap_ShapeFix_EncodeRegularity__SWIG_1" _wrap_ShapeFix_EncodeRegularity__SWIG_1) :void + (shape :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_RemoveSmallEdges" _wrap_ShapeFix_RemoveSmallEdges) :pointer + (shape :pointer) + (Tolerance :double) + (context :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_FixVertexPosition" _wrap_ShapeFix_FixVertexPosition) :bool + (theshape :pointer) + (theTolerance :double) + (thecontext :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_LeastEdgeSize" _wrap_ShapeFix_LeastEdgeSize) :double + (theshape :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Root_Set" _wrap_ShapeFix_Root_Set) :void + (self :pointer) + (Root :pointer)) (cffi:defcfun ("_wrap_ShapeFix_Root_SetContext" _wrap_ShapeFix_Root_SetContext) :void (self :pointer) (context :pointer)) -(cffi:defcfun ("_wrap_ShapeFix_Root_getContext" _wrap_ShapeFix_Root_getContext) :pointer +(cffi:defcfun ("_wrap_ShapeFix_Root_Context" _wrap_ShapeFix_Root_Context) :pointer (self :pointer)) -(cffi:defcfun ("_wrap_delete_ShapeFix_Root" _wrap_delete_ShapeFix_Root) :void +(cffi:defcfun ("_wrap_ShapeFix_Root_SetMsgRegistrator" _wrap_ShapeFix_Root_SetMsgRegistrator) :void + (self :pointer) + (msgreg :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Root_MsgRegistrator" _wrap_ShapeFix_Root_MsgRegistrator) :pointer (self :pointer)) -(cffi:defcfun ("_wrap_new_ShapeFix_Wireframe" _wrap_new_ShapeFix_Wireframe) :pointer - (shape :pointer)) +(cffi:defcfun ("_wrap_ShapeFix_Root_SetPrecision" _wrap_ShapeFix_Root_SetPrecision) :void + (self :pointer) + (preci :double)) -(cffi:defcfun ("_wrap_ShapeFix_Wireframe_FixWireGaps" _wrap_ShapeFix_Wireframe_FixWireGaps) :bool +(cffi:defcfun ("_wrap_ShapeFix_Root_Precision" _wrap_ShapeFix_Root_Precision) :double (self :pointer)) -(cffi:defcfun ("_wrap_ShapeFix_Wireframe_FixSmallEdges" _wrap_ShapeFix_Wireframe_FixSmallEdges) :bool +(cffi:defcfun ("_wrap_ShapeFix_Root_SetMinTolerance" _wrap_ShapeFix_Root_SetMinTolerance) :void + (self :pointer) + (mintol :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Root_MaxTolerance" _wrap_ShapeFix_Root_MaxTolerance) :double (self :pointer)) -(cffi:defcfun ("_wrap_ShapeFix_Wireframe_SetLimitAngle" _wrap_ShapeFix_Wireframe_SetLimitAngle) :void +(cffi:defcfun ("_wrap_ShapeFix_Root_LimitTolerance" _wrap_ShapeFix_Root_LimitTolerance) :double (self :pointer) - (theLimitAngle :double)) + (toler :double)) -(cffi:defcfun ("_wrap_ShapeFix_Wireframe_LimitAngle" _wrap_ShapeFix_Wireframe_LimitAngle) :double - (self :pointer)) +(cffi:defcfun ("_wrap_ShapeFix_Root_SendMsg__SWIG_0" _wrap_ShapeFix_Root_SendMsg__SWIG_0) :void + (self :pointer) + (shape :pointer) + (message :pointer) + (gravity :pointer)) -(cffi:defcfun ("_wrap_ShapeFix_Wireframe_Shape" _wrap_ShapeFix_Wireframe_Shape) :pointer - (self :pointer)) +(cffi:defcfun ("_wrap_ShapeFix_Root_SendMsg__SWIG_1" _wrap_ShapeFix_Root_SendMsg__SWIG_1) :void + (self :pointer) + (shape :pointer) + (message :pointer)) -(cffi:defcfun ("_wrap_ShapeFix_Wireframe_setDropSmallEdges" _wrap_ShapeFix_Wireframe_setDropSmallEdges) :void +(cffi:defcfun ("_wrap_ShapeFix_Root_SendMsg__SWIG_2" _wrap_ShapeFix_Root_SendMsg__SWIG_2) :void (self :pointer) - (b :bool)) + (message :pointer) + (gravity :pointer)) -(cffi:defcfun ("_wrap_ShapeFix_Wireframe_getDropSmallEdges" _wrap_ShapeFix_Wireframe_getDropSmallEdges) :bool - (self :pointer)) +(cffi:defcfun ("_wrap_ShapeFix_Root_SendMsg__SWIG_3" _wrap_ShapeFix_Root_SendMsg__SWIG_3) :void + (self :pointer) + (message :pointer)) -(cffi:defcfun ("_wrap_delete_ShapeFix_Wireframe" _wrap_delete_ShapeFix_Wireframe) :void - (self :pointer)) +(cffi:defcfun ("_wrap_ShapeFix_Root_SendWarning__SWIG_0" _wrap_ShapeFix_Root_SendWarning__SWIG_0) :void + (self :pointer) + (shape :pointer) + (message :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Root_SendWarning__SWIG_1" _wrap_ShapeFix_Root_SendWarning__SWIG_1) :void + (self :pointer) + (message :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Root_SendFail__SWIG_0" _wrap_ShapeFix_Root_SendFail__SWIG_0) :void + (self :pointer) + (shape :pointer) + (message :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Root_SendFail__SWIG_1" _wrap_ShapeFix_Root_SendFail__SWIG_1) :void + (self :pointer) + (message :pointer)) + +(cffi:defcfun ("_wrap_new_ShapeFix_Shape__SWIG_0" _wrap_new_ShapeFix_Shape__SWIG_0) :pointer) -(cffi:defcfun ("_wrap_new_ShapeFix_Shape" _wrap_new_ShapeFix_Shape) :pointer +(cffi:defcfun ("_wrap_new_ShapeFix_Shape__SWIG_1" _wrap_new_ShapeFix_Shape__SWIG_1) :pointer (shape :pointer)) -(cffi:defcfun ("_wrap_ShapeFix_Shape_Shape" _wrap_ShapeFix_Shape_Shape) :pointer - (self :pointer)) +(cffi:defcfun ("_wrap_ShapeFix_Shape_Init" _wrap_ShapeFix_Shape_Init) :void + (self :pointer) + (shape :pointer)) (cffi:defcfun ("_wrap_ShapeFix_Shape_Perform__SWIG_0" _wrap_ShapeFix_Shape_Perform__SWIG_0) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Shape_Perform__SWIG_1" _wrap_ShapeFix_Shape_Perform__SWIG_1) :bool (self :pointer) (theProgress :pointer)) -(cffi:defcfun ("_wrap_ShapeFix_Shape_Perform__SWIG_1" _wrap_ShapeFix_Shape_Perform__SWIG_1) :bool +(cffi:defcfun ("_wrap_ShapeFix_Shape_Shape" _wrap_ShapeFix_Shape_Shape) :pointer (self :pointer)) (cffi:defcfun ("_wrap_ShapeFix_Shape_FixSolidTool" _wrap_ShapeFix_Shape_FixSolidTool) :pointer @@ -9960,10 +10043,366 @@ (cffi:defcfun ("_wrap_ShapeFix_Shape_FixEdgeTool" _wrap_ShapeFix_Shape_FixEdgeTool) :pointer (self :pointer)) -(cffi:defcfun ("_wrap_delete_ShapeFix_Shape" _wrap_delete_ShapeFix_Shape) :void +(cffi:defcfun ("_wrap_ShapeFix_Shape_Status" _wrap_ShapeFix_Shape_Status) :bool + (self :pointer) + (status :pointer)) + +(cffi:defcfun ("_wrap_new_ShapeFix_EdgeProjAux__SWIG_0" _wrap_new_ShapeFix_EdgeProjAux__SWIG_0) :pointer) + +(cffi:defcfun ("_wrap_new_ShapeFix_EdgeProjAux__SWIG_1" _wrap_new_ShapeFix_EdgeProjAux__SWIG_1) :pointer + (F :pointer) + (E :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_EdgeProjAux_Delete" _wrap_ShapeFix_EdgeProjAux_Delete) :void + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_EdgeProjAux_Init" _wrap_ShapeFix_EdgeProjAux_Init) :void + (self :pointer) + (F :pointer) + (E :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_EdgeProjAux_Compute" _wrap_ShapeFix_EdgeProjAux_Compute) :void + (self :pointer) + (preci :double)) + +(cffi:defcfun ("_wrap_ShapeFix_EdgeProjAux_IsFirstDone" _wrap_ShapeFix_EdgeProjAux_IsFirstDone) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_EdgeProjAux_IsLastDone" _wrap_ShapeFix_EdgeProjAux_IsLastDone) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_EdgeProjAux_FirstParam" _wrap_ShapeFix_EdgeProjAux_FirstParam) :double + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_EdgeProjAux_LastParam" _wrap_ShapeFix_EdgeProjAux_LastParam) :double + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_EdgeProjAux_IsIso" _wrap_ShapeFix_EdgeProjAux_IsIso) :bool + (self :pointer) + (C :pointer)) + +(cffi:defcfun ("_wrap_new_ShapeFix_Edge" _wrap_new_ShapeFix_Edge) :pointer) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_Delete" _wrap_ShapeFix_Edge_Delete) :void (self :pointer)) -(cffi:defcfun ("_wrap_delete_Message_ProgressIndicator" _wrap_delete_Message_ProgressIndicator) :void +(cffi:defcfun ("_wrap_ShapeFix_Edge_Projector" _wrap_ShapeFix_Edge_Projector) :pointer + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixRemovePCurve__SWIG_0" _wrap_ShapeFix_Edge_FixRemovePCurve__SWIG_0) :bool + (self :pointer) + (edge :pointer) + (face :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixRemovePCurve__SWIG_1" _wrap_ShapeFix_Edge_FixRemovePCurve__SWIG_1) :bool + (self :pointer) + (edge :pointer) + (surface :pointer) + (location :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixRemoveCurve3d" _wrap_ShapeFix_Edge_FixRemoveCurve3d) :bool + (self :pointer) + (edge :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixAddPCurve__SWIG_0" _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_0) :bool + (self :pointer) + (edge :pointer) + (face :pointer) + (isSeam :bool) + (prec :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixAddPCurve__SWIG_1" _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_1) :bool + (self :pointer) + (edge :pointer) + (face :pointer) + (isSeam :bool)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixAddPCurve__SWIG_2" _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_2) :bool + (self :pointer) + (edge :pointer) + (surface :pointer) + (location :pointer) + (isSeam :bool) + (prec :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixAddPCurve__SWIG_3" _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_3) :bool + (self :pointer) + (edge :pointer) + (surface :pointer) + (location :pointer) + (isSeam :bool)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixAddPCurve__SWIG_4" _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_4) :bool + (self :pointer) + (edge :pointer) + (face :pointer) + (isSeam :bool) + (surfana :pointer) + (prec :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixAddPCurve__SWIG_5" _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_5) :bool + (self :pointer) + (edge :pointer) + (face :pointer) + (isSeam :bool) + (surfana :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixAddPCurve__SWIG_6" _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_6) :bool + (self :pointer) + (edge :pointer) + (surface :pointer) + (location :pointer) + (isSeam :bool) + (surfana :pointer) + (prec :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixAddPCurve__SWIG_7" _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_7) :bool + (self :pointer) + (edge :pointer) + (surface :pointer) + (location :pointer) + (isSeam :bool) + (surfana :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixAddCurve3d" _wrap_ShapeFix_Edge_FixAddCurve3d) :bool + (self :pointer) + (edge :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixVertexTolerance__SWIG_0" _wrap_ShapeFix_Edge_FixVertexTolerance__SWIG_0) :bool + (self :pointer) + (edge :pointer) + (face :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixVertexTolerance__SWIG_1" _wrap_ShapeFix_Edge_FixVertexTolerance__SWIG_1) :bool + (self :pointer) + (edge :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixReversed2d__SWIG_0" _wrap_ShapeFix_Edge_FixReversed2d__SWIG_0) :bool + (self :pointer) + (edge :pointer) + (face :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixReversed2d__SWIG_1" _wrap_ShapeFix_Edge_FixReversed2d__SWIG_1) :bool + (self :pointer) + (edge :pointer) + (surface :pointer) + (location :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixSameParameter__SWIG_0" _wrap_ShapeFix_Edge_FixSameParameter__SWIG_0) :bool + (self :pointer) + (edge :pointer) + (tolerance :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixSameParameter__SWIG_1" _wrap_ShapeFix_Edge_FixSameParameter__SWIG_1) :bool + (self :pointer) + (edge :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixSameParameter__SWIG_2" _wrap_ShapeFix_Edge_FixSameParameter__SWIG_2) :bool + (self :pointer) + (edge :pointer) + (face :pointer) + (tolerance :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_FixSameParameter__SWIG_3" _wrap_ShapeFix_Edge_FixSameParameter__SWIG_3) :bool + (self :pointer) + (edge :pointer) + (face :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_Status" _wrap_ShapeFix_Edge_Status) :bool + (self :pointer) + (status :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_SetContext" _wrap_ShapeFix_Edge_SetContext) :void + (self :pointer) + (context :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Edge_Context" _wrap_ShapeFix_Edge_Context) :pointer + (self :pointer)) + +(cffi:defcfun ("_wrap_new_ShapeFix_Wire__SWIG_0" _wrap_new_ShapeFix_Wire__SWIG_0) :pointer) + +(cffi:defcfun ("_wrap_new_ShapeFix_Wire__SWIG_1" _wrap_new_ShapeFix_Wire__SWIG_1) :pointer + (wire :pointer) + (face :pointer) + (prec :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_Delete" _wrap_ShapeFix_Wire_Delete) :void + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_ClearModes" _wrap_ShapeFix_Wire_ClearModes) :void + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_ClearStatuses" _wrap_ShapeFix_Wire_ClearStatuses) :void + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_Init__SWIG_0" _wrap_ShapeFix_Wire_Init__SWIG_0) :void + (self :pointer) + (wire :pointer) + (face :pointer) + (prec :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_Init__SWIG_1" _wrap_ShapeFix_Wire_Init__SWIG_1) :void + (self :pointer) + (saw :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_Load__SWIG_0" _wrap_ShapeFix_Wire_Load__SWIG_0) :void + (self :pointer) + (wire :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_Load__SWIG_1" _wrap_ShapeFix_Wire_Load__SWIG_1) :void + (self :pointer) + (sbwd :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_SetMaxTailAngle" _wrap_ShapeFix_Wire_SetMaxTailAngle) :void + (self :pointer) + (theMaxTailAngle :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_SetMaxTailWidth" _wrap_ShapeFix_Wire_SetMaxTailWidth) :void + (self :pointer) + (theMaxTailWidth :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_NbEdges" _wrap_ShapeFix_Wire_NbEdges) :int + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_Wire" _wrap_ShapeFix_Wire_Wire) :pointer + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_WireAPIMake" _wrap_ShapeFix_Wire_WireAPIMake) :pointer + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_Analyzer" _wrap_ShapeFix_Wire_Analyzer) :pointer + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_Perform" _wrap_ShapeFix_Wire_Perform) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixReorder__SWIG_0" _wrap_ShapeFix_Wire_FixReorder__SWIG_0) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixSmall__SWIG_0" _wrap_ShapeFix_Wire_FixSmall__SWIG_0) :int + (self :pointer) + (lockvtx :bool) + (precsmall :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixSmall__SWIG_1" _wrap_ShapeFix_Wire_FixSmall__SWIG_1) :int + (self :pointer) + (lockvtx :bool)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixConnected__SWIG_0" _wrap_ShapeFix_Wire_FixConnected__SWIG_0) :bool + (self :pointer) + (prec :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixConnected__SWIG_1" _wrap_ShapeFix_Wire_FixConnected__SWIG_1) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixEdgeCurves" _wrap_ShapeFix_Wire_FixEdgeCurves) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixDegenerated__SWIG_0" _wrap_ShapeFix_Wire_FixDegenerated__SWIG_0) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixSelfIntersection" _wrap_ShapeFix_Wire_FixSelfIntersection) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixLacking__SWIG_0" _wrap_ShapeFix_Wire_FixLacking__SWIG_0) :bool + (self :pointer) + (force :bool)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixLacking__SWIG_1" _wrap_ShapeFix_Wire_FixLacking__SWIG_1) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixClosed__SWIG_0" _wrap_ShapeFix_Wire_FixClosed__SWIG_0) :bool + (self :pointer) + (prec :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixClosed__SWIG_1" _wrap_ShapeFix_Wire_FixClosed__SWIG_1) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixGaps3d" _wrap_ShapeFix_Wire_FixGaps3d) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixGaps2d" _wrap_ShapeFix_Wire_FixGaps2d) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixReorder__SWIG_1" _wrap_ShapeFix_Wire_FixReorder__SWIG_1) :bool + (self :pointer) + (wi :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixSmall__SWIG_2" _wrap_ShapeFix_Wire_FixSmall__SWIG_2) :bool + (self :pointer) + (num :int) + (lockvtx :bool) + (precsmall :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixConnected__SWIG_2" _wrap_ShapeFix_Wire_FixConnected__SWIG_2) :bool + (self :pointer) + (num :int) + (prec :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixSeam" _wrap_ShapeFix_Wire_FixSeam) :bool + (self :pointer) + (num :int)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixShifted" _wrap_ShapeFix_Wire_FixShifted) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixDegenerated__SWIG_1" _wrap_ShapeFix_Wire_FixDegenerated__SWIG_1) :bool + (self :pointer) + (num :int)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixLacking__SWIG_2" _wrap_ShapeFix_Wire_FixLacking__SWIG_2) :bool + (self :pointer) + (num :int) + (force :bool)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixLacking__SWIG_3" _wrap_ShapeFix_Wire_FixLacking__SWIG_3) :bool + (self :pointer) + (num :int)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixNotchedEdges" _wrap_ShapeFix_Wire_FixNotchedEdges) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixGap3d__SWIG_0" _wrap_ShapeFix_Wire_FixGap3d__SWIG_0) :bool + (self :pointer) + (num :int) + (convert :bool)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixGap3d__SWIG_1" _wrap_ShapeFix_Wire_FixGap3d__SWIG_1) :bool + (self :pointer) + (num :int)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixGap2d__SWIG_0" _wrap_ShapeFix_Wire_FixGap2d__SWIG_0) :bool + (self :pointer) + (num :int) + (convert :bool)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixGap2d__SWIG_1" _wrap_ShapeFix_Wire_FixGap2d__SWIG_1) :bool + (self :pointer) + (num :int)) + +(cffi:defcfun ("_wrap_ShapeFix_Wire_FixTails" _wrap_ShapeFix_Wire_FixTails) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_new_ShapeFix_Wireframe" _wrap_new_ShapeFix_Wireframe) :pointer + (shape :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wireframe_Delete" _wrap_ShapeFix_Wireframe_Delete) :void + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wireframe_FixWireGaps" _wrap_ShapeFix_Wireframe_FixWireGaps) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wireframe_FixSmallEdges" _wrap_ShapeFix_Wireframe_FixSmallEdges) :bool + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wireframe_SetLimitAngle" _wrap_ShapeFix_Wireframe_SetLimitAngle) :void + (self :pointer) + (theLimitAngle :double)) + +(cffi:defcfun ("_wrap_ShapeFix_Wireframe_LimitAngle" _wrap_ShapeFix_Wireframe_LimitAngle) :double + (self :pointer)) + +(cffi:defcfun ("_wrap_ShapeFix_Wireframe_Shape" _wrap_ShapeFix_Wireframe_Shape) :pointer (self :pointer)) (cffi:defcfun ("_wrap_new_ShapeAnalysis_Edge" _wrap_new_ShapeAnalysis_Edge) :pointer) @@ -11132,19 +11571,34 @@ (cffi:defcfun ("_wrap_new_BRepMesh_IncrementalMesh__SWIG_0" _wrap_new_BRepMesh_IncrementalMesh__SWIG_0) :pointer) (cffi:defcfun ("_wrap_new_BRepMesh_IncrementalMesh__SWIG_1" _wrap_new_BRepMesh_IncrementalMesh__SWIG_1) :pointer - (S :pointer) - (D :double) - (Relatif :bool) - (Ang :double)) + (theShape :pointer) + (theLinDeflection :double) + (isRelative :bool) + (theAngDeflection :double) + (isInParallel :bool) + (adaptiveMin :bool)) (cffi:defcfun ("_wrap_new_BRepMesh_IncrementalMesh__SWIG_2" _wrap_new_BRepMesh_IncrementalMesh__SWIG_2) :pointer - (S :pointer) - (D :double) - (Relatif :bool)) + (theShape :pointer) + (theLinDeflection :double) + (isRelative :bool) + (theAngDeflection :double) + (isInParallel :bool)) (cffi:defcfun ("_wrap_new_BRepMesh_IncrementalMesh__SWIG_3" _wrap_new_BRepMesh_IncrementalMesh__SWIG_3) :pointer - (S :pointer) - (D :double)) + (theShape :pointer) + (theLinDeflection :double) + (isRelative :bool) + (theAngDeflection :double)) + +(cffi:defcfun ("_wrap_new_BRepMesh_IncrementalMesh__SWIG_4" _wrap_new_BRepMesh_IncrementalMesh__SWIG_4) :pointer + (theShape :pointer) + (theLinDeflection :double) + (isRelative :bool)) + +(cffi:defcfun ("_wrap_new_BRepMesh_IncrementalMesh__SWIG_5" _wrap_new_BRepMesh_IncrementalMesh__SWIG_5) :pointer + (theShape :pointer) + (theLinDeflection :double)) (cffi:defcfun ("_wrap_BRepMesh_IncrementalMesh_Perform" _wrap_BRepMesh_IncrementalMesh_Perform) :void (self :pointer)) diff --git a/src/oc_wrap.cxx b/src/oc_wrap.cxx index 7df7d9c8..a1b71920 100644 --- a/src/oc_wrap.cxx +++ b/src/oc_wrap.cxx @@ -44723,6 +44723,50 @@ EXPORT void _wrap_TColgp_Array1OfPnt_Delete (TColgp_Array1OfPnt *larg1) { } +SWIGINTERN void TColgp_Array1OfPnt_GetPoint(TColgp_Array1OfPnt *self,Standard_Integer const Index,Standard_Real &x,Standard_Real &y,Standard_Real &z){ + gp_Pnt result = (self)->Value(Index); + x = result.X(); + y = result.Y(); + z = result.Z(); + } +EXPORT void _wrap_TColgp_Array1OfPnt_GetPoint (TColgp_Array1OfPnt *larg1, Standard_Integer larg2, Standard_Real *larg3, Standard_Real *larg4, Standard_Real *larg5) { + TColgp_Array1OfPnt *arg1 = (TColgp_Array1OfPnt *) 0 ; + Standard_Integer arg2 ; + Standard_Real *arg3 = 0 ; + Standard_Real *arg4 = 0 ; + Standard_Real *arg5 = 0 ; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = larg4; + arg5 = larg5; + try { + { + try + { + OCC_CATCH_SIGNALS + TColgp_Array1OfPnt_GetPoint(arg1,arg2,*arg3,*arg4,*arg5); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: TColgp_Array1OfPnt_GetPoint\n * wrapname: _wrap_TColgp_Array1OfPnt_GetPoint\n * fulldecl: void TColgp_Array1OfPnt::GetPoint(Standard_Integer const,Standard_Real &,Standard_Real &,Standard_Real &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + #include @@ -50744,7 +50788,7 @@ EXPORT TopoDS_Vertex *_wrap_BRepBuilderAPI_MakeVertex_Vertex (BRepBuilderAPI_Mak try { OCC_CATCH_SIGNALS - result = (TopoDS_Vertex *) &((BRepBuilderAPI_MakeVertex *)arg1)->Vertex(); + result = (TopoDS_Vertex *) &(arg1)->Vertex(); } catch(Standard_Failure const& error) { @@ -51212,7 +51256,7 @@ EXPORT TopoDS_Wire *_wrap_BRepBuilderAPI_MakeWire_Wire (BRepBuilderAPI_MakeWire try { OCC_CATCH_SIGNALS - result = (TopoDS_Wire *) &((BRepBuilderAPI_MakeWire *)arg1)->Wire(); + result = (TopoDS_Wire *) &(arg1)->Wire(); } catch(Standard_Failure const& error) { @@ -52747,7 +52791,7 @@ EXPORT TopoDS_Edge *_wrap_BRepBuilderAPI_MakeEdge_Edge (BRepBuilderAPI_MakeEdge try { OCC_CATCH_SIGNALS - result = (TopoDS_Edge *) &((BRepBuilderAPI_MakeEdge *)arg1)->Edge(); + result = (TopoDS_Edge *) &(arg1)->Edge(); } catch(Standard_Failure const& error) { @@ -84797,9 +84841,167 @@ EXPORT void _wrap_delete_IGESControl_Controller (IGESControl_Controller *larg1) #include #include #include +#include +#include +#include + + +#include + +EXPORT bool _wrap_ShapeFix_SameParameter__SWIG_0 (TopoDS_Shape *larg1, bool larg2) { + bool lresult = (bool)0 ; + TopoDS_Shape *arg1 = 0 ; + Standard_Boolean arg2 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = (bool)larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)ShapeFix::SameParameter((TopoDS_Shape const &)*arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_SameParameter\n * wrapname: _wrap_ShapeFix_SameParameter__SWIG_0\n * fulldecl: Standard_Boolean ShapeFix::SameParameter(TopoDS_Shape const &,Standard_Boolean const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_SameParameter__SWIG_1 (TopoDS_Shape *larg1, bool larg2, Standard_Real larg3) { + bool lresult = (bool)0 ; + TopoDS_Shape *arg1 = 0 ; + Standard_Boolean arg2 ; + Standard_Real arg3 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = (bool)larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)ShapeFix::SameParameter((TopoDS_Shape const &)*arg1,arg2,arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_SameParameter\n * wrapname: _wrap_ShapeFix_SameParameter__SWIG_1\n * fulldecl: Standard_Boolean ShapeFix::SameParameter(TopoDS_Shape const &,Standard_Boolean const,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + -EXPORT void _wrap_ShapeFix_Root_SetPrecision (ShapeFix_Root *larg1, Standard_Real larg2) { - ShapeFix_Root *arg1 = (ShapeFix_Root *) 0 ; +EXPORT bool _wrap_ShapeFix_SameParameter__SWIG_2 (TopoDS_Shape *larg1, bool larg2, Standard_Real larg3, Handle_Message_ProgressIndicator *larg4) { + bool lresult = (bool)0 ; + TopoDS_Shape *arg1 = 0 ; + Standard_Boolean arg2 ; + Standard_Real arg3 ; + Handle_Message_ProgressIndicator *arg4 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = (bool)larg2; + arg3 = larg3; + arg4 = larg4; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)ShapeFix::SameParameter((TopoDS_Shape const &)*arg1,arg2,arg3,(Handle_Message_ProgressIndicator const &)*arg4); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_SameParameter\n * wrapname: _wrap_ShapeFix_SameParameter__SWIG_2\n * fulldecl: Standard_Boolean ShapeFix::SameParameter(TopoDS_Shape const &,Standard_Boolean const,Standard_Real const,Handle_Message_ProgressIndicator const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_SameParameter__SWIG_3 (TopoDS_Shape *larg1, bool larg2, Standard_Real larg3, Handle_Message_ProgressIndicator *larg4, Handle_ShapeExtend_BasicMsgRegistrator *larg5) { + bool lresult = (bool)0 ; + TopoDS_Shape *arg1 = 0 ; + Standard_Boolean arg2 ; + Standard_Real arg3 ; + Handle_Message_ProgressIndicator *arg4 = 0 ; + Handle_ShapeExtend_BasicMsgRegistrator *arg5 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = (bool)larg2; + arg3 = larg3; + arg4 = larg4; + arg5 = larg5; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)ShapeFix::SameParameter((TopoDS_Shape const &)*arg1,arg2,arg3,(Handle_Message_ProgressIndicator const &)*arg4,(Handle_ShapeExtend_BasicMsgRegistrator const &)*arg5); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_SameParameter\n * wrapname: _wrap_ShapeFix_SameParameter__SWIG_3\n * fulldecl: Standard_Boolean ShapeFix::SameParameter(TopoDS_Shape const &,Standard_Boolean const,Standard_Real const,Handle_Message_ProgressIndicator const &,Handle_ShapeExtend_BasicMsgRegistrator const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT void _wrap_ShapeFix_EncodeRegularity__SWIG_0 (TopoDS_Shape *larg1, Standard_Real larg2) { + TopoDS_Shape *arg1 = 0 ; Standard_Real arg2 ; arg1 = larg1; @@ -84809,7 +85011,37 @@ EXPORT void _wrap_ShapeFix_Root_SetPrecision (ShapeFix_Root *larg1, Standard_Rea try { OCC_CATCH_SIGNALS - (arg1)->SetPrecision(arg2); + ShapeFix::EncodeRegularity((TopoDS_Shape const &)*arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_EncodeRegularity\n * wrapname: _wrap_ShapeFix_EncodeRegularity__SWIG_0\n * fulldecl: void ShapeFix::EncodeRegularity(TopoDS_Shape const &,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +EXPORT void _wrap_ShapeFix_EncodeRegularity__SWIG_1 (TopoDS_Shape *larg1) { + TopoDS_Shape *arg1 = 0 ; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + ShapeFix::EncodeRegularity((TopoDS_Shape const &)*arg1); } catch(Standard_Failure const& error) { @@ -84819,7 +85051,7 @@ EXPORT void _wrap_ShapeFix_Root_SetPrecision (ShapeFix_Root *larg1, Standard_Rea if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Root_SetPrecision\n * wrapname: _wrap_ShapeFix_Root_SetPrecision\n * fulldecl: void ShapeFix_Root::SetPrecision(Standard_Real const)"; + message += "\nwrapper details:\n * symname: ShapeFix_EncodeRegularity\n * wrapname: _wrap_ShapeFix_EncodeRegularity__SWIG_1\n * fulldecl: void ShapeFix::EncodeRegularity(TopoDS_Shape const &)"; signal_lisp_error(message.c_str()); } } @@ -84830,9 +85062,83 @@ EXPORT void _wrap_ShapeFix_Root_SetPrecision (ShapeFix_Root *larg1, Standard_Rea } -EXPORT Standard_Real _wrap_ShapeFix_Root_Precision (ShapeFix_Root *larg1) { +EXPORT TopoDS_Shape *_wrap_ShapeFix_RemoveSmallEdges (TopoDS_Shape *larg1, Standard_Real larg2, Handle_ShapeBuild_ReShape *larg3) { + TopoDS_Shape * lresult = (TopoDS_Shape *)0 ; + TopoDS_Shape *arg1 = 0 ; + Standard_Real arg2 ; + Handle_ShapeBuild_ReShape *arg3 = 0 ; + TopoDS_Shape result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = ShapeFix::RemoveSmallEdges(*arg1,arg2,*arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_RemoveSmallEdges\n * wrapname: _wrap_ShapeFix_RemoveSmallEdges\n * fulldecl: TopoDS_Shape ShapeFix::RemoveSmallEdges(TopoDS_Shape &,Standard_Real const,Handle_ShapeBuild_ReShape &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = new TopoDS_Shape(result); + return lresult; + } catch (...) { + return (TopoDS_Shape *)0; + } +} + + +EXPORT bool _wrap_ShapeFix_FixVertexPosition (TopoDS_Shape *larg1, Standard_Real larg2, Handle_ShapeBuild_ReShape *larg3) { + bool lresult = (bool)0 ; + TopoDS_Shape *arg1 = 0 ; + Standard_Real arg2 ; + Handle_ShapeBuild_ReShape *arg3 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)ShapeFix::FixVertexPosition(*arg1,arg2,(Handle_ShapeBuild_ReShape const &)*arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_FixVertexPosition\n * wrapname: _wrap_ShapeFix_FixVertexPosition\n * fulldecl: Standard_Boolean ShapeFix::FixVertexPosition(TopoDS_Shape &,Standard_Real const,Handle_ShapeBuild_ReShape const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT Standard_Real _wrap_ShapeFix_LeastEdgeSize (TopoDS_Shape *larg1) { Standard_Real lresult = (Standard_Real)0 ; - ShapeFix_Root *arg1 = (ShapeFix_Root *) 0 ; + TopoDS_Shape *arg1 = 0 ; Standard_Real result; arg1 = larg1; @@ -84841,7 +85147,7 @@ EXPORT Standard_Real _wrap_ShapeFix_Root_Precision (ShapeFix_Root *larg1) { try { OCC_CATCH_SIGNALS - result = (Standard_Real)((ShapeFix_Root const *)arg1)->Precision(); + result = (Standard_Real)ShapeFix::LeastEdgeSize(*arg1); } catch(Standard_Failure const& error) { @@ -84851,7 +85157,7 @@ EXPORT Standard_Real _wrap_ShapeFix_Root_Precision (ShapeFix_Root *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Root_Precision\n * wrapname: _wrap_ShapeFix_Root_Precision\n * fulldecl: Standard_Real ShapeFix_Root::Precision() const"; + message += "\nwrapper details:\n * symname: ShapeFix_LeastEdgeSize\n * wrapname: _wrap_ShapeFix_LeastEdgeSize\n * fulldecl: Standard_Real ShapeFix::LeastEdgeSize(TopoDS_Shape &)"; signal_lisp_error(message.c_str()); } } @@ -84863,9 +85169,12 @@ EXPORT Standard_Real _wrap_ShapeFix_Root_Precision (ShapeFix_Root *larg1) { } -EXPORT void _wrap_ShapeFix_Root_SetContext (ShapeFix_Root *larg1, ShapeBuild_ReShape *larg2) { - ShapeFix_Root *arg1 = (ShapeFix_Root *) 0 ; - ShapeBuild_ReShape *arg2 = (ShapeBuild_ReShape *) 0 ; +SWIGINTERN void Handle_ShapeFix_Root_Set(Handle_ShapeFix_Root *self,Handle_ShapeFix_Root const &Root){ + (*self)->Set(Root); + } +EXPORT void _wrap_ShapeFix_Root_Set (Handle_ShapeFix_Root *larg1, Handle_ShapeFix_Root *larg2) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Handle_ShapeFix_Root *arg2 = 0 ; arg1 = larg1; arg2 = larg2; @@ -84874,7 +85183,7 @@ EXPORT void _wrap_ShapeFix_Root_SetContext (ShapeFix_Root *larg1, ShapeBuild_ReS try { OCC_CATCH_SIGNALS - (arg1)->SetContext((ShapeBuild_ReShape const *)arg2); + Handle_ShapeFix_Root_Set(arg1,(Handle_ShapeFix_Root const &)*arg2); } catch(Standard_Failure const& error) { @@ -84884,7 +85193,7 @@ EXPORT void _wrap_ShapeFix_Root_SetContext (ShapeFix_Root *larg1, ShapeBuild_ReS if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Root_SetContext\n * wrapname: _wrap_ShapeFix_Root_SetContext\n * fulldecl: void ShapeFix_Root::SetContext(ShapeBuild_ReShape const *)"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_Set\n * wrapname: _wrap_ShapeFix_Root_Set\n * fulldecl: void Handle_ShapeFix_Root::Set(Handle_ShapeFix_Root const &)"; signal_lisp_error(message.c_str()); } } @@ -84895,13 +85204,47 @@ EXPORT void _wrap_ShapeFix_Root_SetContext (ShapeFix_Root *larg1, ShapeBuild_ReS } -SWIGINTERN Handle_ShapeBuild_ReShape ShapeFix_Root_getContext(ShapeFix_Root *self){ - Handle_ShapeBuild_ReShape p = self->Context(); - return p; +SWIGINTERN void Handle_ShapeFix_Root_SetContext(Handle_ShapeFix_Root *self,Handle_ShapeBuild_ReShape const &context){ + (*self)->SetContext(context); + } +EXPORT void _wrap_ShapeFix_Root_SetContext (Handle_ShapeFix_Root *larg1, Handle_ShapeBuild_ReShape *larg2) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Handle_ShapeBuild_ReShape *arg2 = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Root_SetContext(arg1,(Handle_ShapeBuild_ReShape const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Root_SetContext\n * wrapname: _wrap_ShapeFix_Root_SetContext\n * fulldecl: void Handle_ShapeFix_Root::SetContext(Handle_ShapeBuild_ReShape const &)"; + signal_lisp_error(message.c_str()); + } } -EXPORT Handle_ShapeBuild_ReShape *_wrap_ShapeFix_Root_getContext (ShapeFix_Root *larg1) { + + } catch (...) { + + } +} + + +SWIGINTERN Handle_ShapeBuild_ReShape Handle_ShapeFix_Root_Context(Handle_ShapeFix_Root *self){ + return (*self)->Context(); + } +EXPORT Handle_ShapeBuild_ReShape *_wrap_ShapeFix_Root_Context (Handle_ShapeFix_Root *larg1) { Handle_ShapeBuild_ReShape * lresult = (Handle_ShapeBuild_ReShape *)0 ; - ShapeFix_Root *arg1 = (ShapeFix_Root *) 0 ; + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; Handle_ShapeBuild_ReShape result; arg1 = larg1; @@ -84910,7 +85253,7 @@ EXPORT Handle_ShapeBuild_ReShape *_wrap_ShapeFix_Root_getContext (ShapeFix_Root try { OCC_CATCH_SIGNALS - result = ShapeFix_Root_getContext(arg1); + result = Handle_ShapeFix_Root_Context(arg1); } catch(Standard_Failure const& error) { @@ -84920,7 +85263,7 @@ EXPORT Handle_ShapeBuild_ReShape *_wrap_ShapeFix_Root_getContext (ShapeFix_Root if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Root_getContext\n * wrapname: _wrap_ShapeFix_Root_getContext\n * fulldecl: Handle_ShapeBuild_ReShape ShapeFix_Root::getContext()"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_Context\n * wrapname: _wrap_ShapeFix_Root_Context\n * fulldecl: Handle_ShapeBuild_ReShape Handle_ShapeFix_Root::Context()"; signal_lisp_error(message.c_str()); } } @@ -84932,16 +85275,21 @@ EXPORT Handle_ShapeBuild_ReShape *_wrap_ShapeFix_Root_getContext (ShapeFix_Root } -EXPORT void _wrap_delete_ShapeFix_Root (ShapeFix_Root *larg1) { - ShapeFix_Root *arg1 = (ShapeFix_Root *) 0 ; +SWIGINTERN void Handle_ShapeFix_Root_SetMsgRegistrator(Handle_ShapeFix_Root *self,Handle_ShapeExtend_BasicMsgRegistrator const &msgreg){ + (*self)->SetMsgRegistrator(msgreg); + } +EXPORT void _wrap_ShapeFix_Root_SetMsgRegistrator (Handle_ShapeFix_Root *larg1, Handle_ShapeExtend_BasicMsgRegistrator *larg2) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Handle_ShapeExtend_BasicMsgRegistrator *arg2 = 0 ; arg1 = larg1; + arg2 = larg2; try { { try { OCC_CATCH_SIGNALS - delete arg1; + Handle_ShapeFix_Root_SetMsgRegistrator(arg1,(Handle_ShapeExtend_BasicMsgRegistrator const &)*arg2); } catch(Standard_Failure const& error) { @@ -84951,7 +85299,7 @@ EXPORT void _wrap_delete_ShapeFix_Root (ShapeFix_Root *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: delete_ShapeFix_Root\n * wrapname: _wrap_delete_ShapeFix_Root\n * fulldecl: ShapeFix_Root::~ShapeFix_Root()"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_SetMsgRegistrator\n * wrapname: _wrap_ShapeFix_Root_SetMsgRegistrator\n * fulldecl: void Handle_ShapeFix_Root::SetMsgRegistrator(Handle_ShapeExtend_BasicMsgRegistrator const &)"; signal_lisp_error(message.c_str()); } } @@ -84962,10 +85310,13 @@ EXPORT void _wrap_delete_ShapeFix_Root (ShapeFix_Root *larg1) { } -EXPORT ShapeFix_Wireframe *_wrap_new_ShapeFix_Wireframe (TopoDS_Shape *larg1) { - ShapeFix_Wireframe * lresult = (ShapeFix_Wireframe *)0 ; - TopoDS_Shape *arg1 = 0 ; - ShapeFix_Wireframe *result = 0 ; +SWIGINTERN Handle_ShapeExtend_BasicMsgRegistrator Handle_ShapeFix_Root_MsgRegistrator(Handle_ShapeFix_Root *self){ + return (*self)->MsgRegistrator(); + } +EXPORT Handle_ShapeExtend_BasicMsgRegistrator *_wrap_ShapeFix_Root_MsgRegistrator (Handle_ShapeFix_Root *larg1) { + Handle_ShapeExtend_BasicMsgRegistrator * lresult = (Handle_ShapeExtend_BasicMsgRegistrator *)0 ; + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Handle_ShapeExtend_BasicMsgRegistrator result; arg1 = larg1; try { @@ -84973,7 +85324,7 @@ EXPORT ShapeFix_Wireframe *_wrap_new_ShapeFix_Wireframe (TopoDS_Shape *larg1) { try { OCC_CATCH_SIGNALS - result = (ShapeFix_Wireframe *)new ShapeFix_Wireframe((TopoDS_Shape const &)*arg1); + result = Handle_ShapeFix_Root_MsgRegistrator(arg1); } catch(Standard_Failure const& error) { @@ -84983,30 +85334,33 @@ EXPORT ShapeFix_Wireframe *_wrap_new_ShapeFix_Wireframe (TopoDS_Shape *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: new_ShapeFix_Wireframe\n * wrapname: _wrap_new_ShapeFix_Wireframe\n * fulldecl: ShapeFix_Wireframe::ShapeFix_Wireframe(TopoDS_Shape const &)"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_MsgRegistrator\n * wrapname: _wrap_ShapeFix_Root_MsgRegistrator\n * fulldecl: Handle_ShapeExtend_BasicMsgRegistrator Handle_ShapeFix_Root::MsgRegistrator()"; signal_lisp_error(message.c_str()); } } - lresult = result; + lresult = new Handle_ShapeExtend_BasicMsgRegistrator(result); return lresult; } catch (...) { - return (ShapeFix_Wireframe *)0; + return (Handle_ShapeExtend_BasicMsgRegistrator *)0; } } -EXPORT bool _wrap_ShapeFix_Wireframe_FixWireGaps (ShapeFix_Wireframe *larg1) { - bool lresult = (bool)0 ; - ShapeFix_Wireframe *arg1 = (ShapeFix_Wireframe *) 0 ; - Standard_Boolean result; +SWIGINTERN void Handle_ShapeFix_Root_SetPrecision(Handle_ShapeFix_Root *self,Standard_Real const preci){ + (*self)->SetPrecision(preci); + } +EXPORT void _wrap_ShapeFix_Root_SetPrecision (Handle_ShapeFix_Root *larg1, Standard_Real larg2) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Standard_Real arg2 ; arg1 = larg1; + arg2 = larg2; try { { try { OCC_CATCH_SIGNALS - result = (Standard_Boolean)(arg1)->FixWireGaps(); + Handle_ShapeFix_Root_SetPrecision(arg1,arg2); } catch(Standard_Failure const& error) { @@ -85016,22 +85370,24 @@ EXPORT bool _wrap_ShapeFix_Wireframe_FixWireGaps (ShapeFix_Wireframe *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_FixWireGaps\n * wrapname: _wrap_ShapeFix_Wireframe_FixWireGaps\n * fulldecl: Standard_Boolean ShapeFix_Wireframe::FixWireGaps()"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_SetPrecision\n * wrapname: _wrap_ShapeFix_Root_SetPrecision\n * fulldecl: void Handle_ShapeFix_Root::SetPrecision(Standard_Real const)"; signal_lisp_error(message.c_str()); } } - lresult = (bool)result; - return lresult; + } catch (...) { - return (bool)0; + } } -EXPORT bool _wrap_ShapeFix_Wireframe_FixSmallEdges (ShapeFix_Wireframe *larg1) { - bool lresult = (bool)0 ; - ShapeFix_Wireframe *arg1 = (ShapeFix_Wireframe *) 0 ; - Standard_Boolean result; +SWIGINTERN Standard_Real Handle_ShapeFix_Root_Precision(Handle_ShapeFix_Root *self){ + return (*self)->Precision(); + } +EXPORT Standard_Real _wrap_ShapeFix_Root_Precision (Handle_ShapeFix_Root *larg1) { + Standard_Real lresult = (Standard_Real)0 ; + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Standard_Real result; arg1 = larg1; try { @@ -85039,7 +85395,7 @@ EXPORT bool _wrap_ShapeFix_Wireframe_FixSmallEdges (ShapeFix_Wireframe *larg1) { try { OCC_CATCH_SIGNALS - result = (Standard_Boolean)(arg1)->FixSmallEdges(); + result = (Standard_Real)Handle_ShapeFix_Root_Precision(arg1); } catch(Standard_Failure const& error) { @@ -85049,20 +85405,23 @@ EXPORT bool _wrap_ShapeFix_Wireframe_FixSmallEdges (ShapeFix_Wireframe *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_FixSmallEdges\n * wrapname: _wrap_ShapeFix_Wireframe_FixSmallEdges\n * fulldecl: Standard_Boolean ShapeFix_Wireframe::FixSmallEdges()"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_Precision\n * wrapname: _wrap_ShapeFix_Root_Precision\n * fulldecl: Standard_Real Handle_ShapeFix_Root::Precision()"; signal_lisp_error(message.c_str()); } } - lresult = (bool)result; + lresult = result; return lresult; } catch (...) { - return (bool)0; + return (Standard_Real)0; } } -EXPORT void _wrap_ShapeFix_Wireframe_SetLimitAngle (ShapeFix_Wireframe *larg1, Standard_Real larg2) { - ShapeFix_Wireframe *arg1 = (ShapeFix_Wireframe *) 0 ; +SWIGINTERN void Handle_ShapeFix_Root_SetMinTolerance(Handle_ShapeFix_Root *self,Standard_Real const mintol){ + (*self)->SetMinTolerance(mintol); + } +EXPORT void _wrap_ShapeFix_Root_SetMinTolerance (Handle_ShapeFix_Root *larg1, Standard_Real larg2) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; Standard_Real arg2 ; arg1 = larg1; @@ -85072,7 +85431,7 @@ EXPORT void _wrap_ShapeFix_Wireframe_SetLimitAngle (ShapeFix_Wireframe *larg1, S try { OCC_CATCH_SIGNALS - (arg1)->SetLimitAngle(arg2); + Handle_ShapeFix_Root_SetMinTolerance(arg1,arg2); } catch(Standard_Failure const& error) { @@ -85082,7 +85441,7 @@ EXPORT void _wrap_ShapeFix_Wireframe_SetLimitAngle (ShapeFix_Wireframe *larg1, S if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_SetLimitAngle\n * wrapname: _wrap_ShapeFix_Wireframe_SetLimitAngle\n * fulldecl: void ShapeFix_Wireframe::SetLimitAngle(Standard_Real const)"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_SetMinTolerance\n * wrapname: _wrap_ShapeFix_Root_SetMinTolerance\n * fulldecl: void Handle_ShapeFix_Root::SetMinTolerance(Standard_Real const)"; signal_lisp_error(message.c_str()); } } @@ -85093,9 +85452,12 @@ EXPORT void _wrap_ShapeFix_Wireframe_SetLimitAngle (ShapeFix_Wireframe *larg1, S } -EXPORT Standard_Real _wrap_ShapeFix_Wireframe_LimitAngle (ShapeFix_Wireframe *larg1) { +SWIGINTERN Standard_Real Handle_ShapeFix_Root_MaxTolerance(Handle_ShapeFix_Root *self){ + return (*self)->MaxTolerance(); + } +EXPORT Standard_Real _wrap_ShapeFix_Root_MaxTolerance (Handle_ShapeFix_Root *larg1) { Standard_Real lresult = (Standard_Real)0 ; - ShapeFix_Wireframe *arg1 = (ShapeFix_Wireframe *) 0 ; + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; Standard_Real result; arg1 = larg1; @@ -85104,7 +85466,7 @@ EXPORT Standard_Real _wrap_ShapeFix_Wireframe_LimitAngle (ShapeFix_Wireframe *la try { OCC_CATCH_SIGNALS - result = (Standard_Real)((ShapeFix_Wireframe const *)arg1)->LimitAngle(); + result = (Standard_Real)Handle_ShapeFix_Root_MaxTolerance(arg1); } catch(Standard_Failure const& error) { @@ -85114,7 +85476,7 @@ EXPORT Standard_Real _wrap_ShapeFix_Wireframe_LimitAngle (ShapeFix_Wireframe *la if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_LimitAngle\n * wrapname: _wrap_ShapeFix_Wireframe_LimitAngle\n * fulldecl: Standard_Real ShapeFix_Wireframe::LimitAngle() const"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_MaxTolerance\n * wrapname: _wrap_ShapeFix_Root_MaxTolerance\n * fulldecl: Standard_Real Handle_ShapeFix_Root::MaxTolerance()"; signal_lisp_error(message.c_str()); } } @@ -85126,18 +85488,23 @@ EXPORT Standard_Real _wrap_ShapeFix_Wireframe_LimitAngle (ShapeFix_Wireframe *la } -EXPORT TopoDS_Shape *_wrap_ShapeFix_Wireframe_Shape (ShapeFix_Wireframe *larg1) { - TopoDS_Shape * lresult = (TopoDS_Shape *)0 ; - ShapeFix_Wireframe *arg1 = (ShapeFix_Wireframe *) 0 ; - TopoDS_Shape result; +SWIGINTERN Standard_Real Handle_ShapeFix_Root_LimitTolerance(Handle_ShapeFix_Root *self,Standard_Real const toler){ + return (*self)->LimitTolerance(toler); + } +EXPORT Standard_Real _wrap_ShapeFix_Root_LimitTolerance (Handle_ShapeFix_Root *larg1, Standard_Real larg2) { + Standard_Real lresult = (Standard_Real)0 ; + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Standard_Real arg2 ; + Standard_Real result; arg1 = larg1; + arg2 = larg2; try { { try { OCC_CATCH_SIGNALS - result = (arg1)->Shape(); + result = (Standard_Real)Handle_ShapeFix_Root_LimitTolerance(arg1,arg2); } catch(Standard_Failure const& error) { @@ -85147,33 +85514,37 @@ EXPORT TopoDS_Shape *_wrap_ShapeFix_Wireframe_Shape (ShapeFix_Wireframe *larg1) if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_Shape\n * wrapname: _wrap_ShapeFix_Wireframe_Shape\n * fulldecl: TopoDS_Shape ShapeFix_Wireframe::Shape()"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_LimitTolerance\n * wrapname: _wrap_ShapeFix_Root_LimitTolerance\n * fulldecl: Standard_Real Handle_ShapeFix_Root::LimitTolerance(Standard_Real const)"; signal_lisp_error(message.c_str()); } } - lresult = new TopoDS_Shape(result); + lresult = result; return lresult; } catch (...) { - return (TopoDS_Shape *)0; + return (Standard_Real)0; } } -SWIGINTERN void ShapeFix_Wireframe_setDropSmallEdges(ShapeFix_Wireframe *self,bool b){ - self->ModeDropSmallEdges()=b; - } -EXPORT void _wrap_ShapeFix_Wireframe_setDropSmallEdges (ShapeFix_Wireframe *larg1, bool larg2) { - ShapeFix_Wireframe *arg1 = (ShapeFix_Wireframe *) 0 ; - bool arg2 ; +SWIGINTERN void Handle_ShapeFix_Root_SendMsg__SWIG_0(Handle_ShapeFix_Root *self,TopoDS_Shape const &shape,Message_Msg const &message,Message_Gravity const gravity=Message_Info){ + (*self)->SendMsg(shape, message, gravity); + } +EXPORT void _wrap_ShapeFix_Root_SendMsg__SWIG_0 (Handle_ShapeFix_Root *larg1, TopoDS_Shape *larg2, Message_Msg *larg3, Message_Gravity const *larg4) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + TopoDS_Shape *arg2 = 0 ; + Message_Msg *arg3 = 0 ; + Message_Gravity arg4 ; arg1 = larg1; - arg2 = (bool)larg2; + arg2 = larg2; + arg3 = larg3; + arg4 = *larg4; try { { try { OCC_CATCH_SIGNALS - ShapeFix_Wireframe_setDropSmallEdges(arg1,arg2); + Handle_ShapeFix_Root_SendMsg__SWIG_0(arg1,(TopoDS_Shape const &)*arg2,(Message_Msg const &)*arg3,arg4); } catch(Standard_Failure const& error) { @@ -85183,7 +85554,7 @@ EXPORT void _wrap_ShapeFix_Wireframe_setDropSmallEdges (ShapeFix_Wireframe *larg if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_setDropSmallEdges\n * wrapname: _wrap_ShapeFix_Wireframe_setDropSmallEdges\n * fulldecl: void ShapeFix_Wireframe::setDropSmallEdges(bool)"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_SendMsg\n * wrapname: _wrap_ShapeFix_Root_SendMsg__SWIG_0\n * fulldecl: void Handle_ShapeFix_Root::SendMsg(TopoDS_Shape const &,Message_Msg const &,Message_Gravity const)"; signal_lisp_error(message.c_str()); } } @@ -85194,21 +85565,20 @@ EXPORT void _wrap_ShapeFix_Wireframe_setDropSmallEdges (ShapeFix_Wireframe *larg } -SWIGINTERN bool ShapeFix_Wireframe_getDropSmallEdges(ShapeFix_Wireframe *self){ - return self->ModeDropSmallEdges()!=0; - } -EXPORT bool _wrap_ShapeFix_Wireframe_getDropSmallEdges (ShapeFix_Wireframe *larg1) { - bool lresult = (bool)0 ; - ShapeFix_Wireframe *arg1 = (ShapeFix_Wireframe *) 0 ; - bool result; +EXPORT void _wrap_ShapeFix_Root_SendMsg__SWIG_1 (Handle_ShapeFix_Root *larg1, TopoDS_Shape *larg2, Message_Msg *larg3) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + TopoDS_Shape *arg2 = 0 ; + Message_Msg *arg3 = 0 ; arg1 = larg1; + arg2 = larg2; + arg3 = larg3; try { { try { OCC_CATCH_SIGNALS - result = (bool)ShapeFix_Wireframe_getDropSmallEdges(arg1); + Handle_ShapeFix_Root_SendMsg__SWIG_0(arg1,(TopoDS_Shape const &)*arg2,(Message_Msg const &)*arg3); } catch(Standard_Failure const& error) { @@ -85218,28 +85588,210 @@ EXPORT bool _wrap_ShapeFix_Wireframe_getDropSmallEdges (ShapeFix_Wireframe *larg if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_getDropSmallEdges\n * wrapname: _wrap_ShapeFix_Wireframe_getDropSmallEdges\n * fulldecl: bool ShapeFix_Wireframe::getDropSmallEdges()"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_SendMsg\n * wrapname: _wrap_ShapeFix_Root_SendMsg__SWIG_1\n * fulldecl: void Handle_ShapeFix_Root::SendMsg(TopoDS_Shape const &,Message_Msg const &)"; signal_lisp_error(message.c_str()); } } - lresult = (bool)result; - return lresult; + } catch (...) { - return (bool)0; + } } -EXPORT void _wrap_delete_ShapeFix_Wireframe (ShapeFix_Wireframe *larg1) { - ShapeFix_Wireframe *arg1 = (ShapeFix_Wireframe *) 0 ; +SWIGINTERN void Handle_ShapeFix_Root_SendMsg__SWIG_2(Handle_ShapeFix_Root *self,Message_Msg const &message,Message_Gravity const gravity=Message_Info){ + (*self)->SendMsg(message, gravity); + } +EXPORT void _wrap_ShapeFix_Root_SendMsg__SWIG_2 (Handle_ShapeFix_Root *larg1, Message_Msg *larg2, Message_Gravity const *larg3) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Message_Msg *arg2 = 0 ; + Message_Gravity arg3 ; arg1 = larg1; + arg2 = larg2; + arg3 = *larg3; try { { try { OCC_CATCH_SIGNALS - delete arg1; + Handle_ShapeFix_Root_SendMsg__SWIG_2(arg1,(Message_Msg const &)*arg2,arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Root_SendMsg\n * wrapname: _wrap_ShapeFix_Root_SendMsg__SWIG_2\n * fulldecl: void Handle_ShapeFix_Root::SendMsg(Message_Msg const &,Message_Gravity const)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +EXPORT void _wrap_ShapeFix_Root_SendMsg__SWIG_3 (Handle_ShapeFix_Root *larg1, Message_Msg *larg2) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Message_Msg *arg2 = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Root_SendMsg__SWIG_2(arg1,(Message_Msg const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Root_SendMsg\n * wrapname: _wrap_ShapeFix_Root_SendMsg__SWIG_3\n * fulldecl: void Handle_ShapeFix_Root::SendMsg(Message_Msg const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Root_SendWarning__SWIG_0(Handle_ShapeFix_Root *self,TopoDS_Shape const &shape,Message_Msg const &message){ + (*self)->SendWarning(shape, message); + } +EXPORT void _wrap_ShapeFix_Root_SendWarning__SWIG_0 (Handle_ShapeFix_Root *larg1, TopoDS_Shape *larg2, Message_Msg *larg3) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + TopoDS_Shape *arg2 = 0 ; + Message_Msg *arg3 = 0 ; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Root_SendWarning__SWIG_0(arg1,(TopoDS_Shape const &)*arg2,(Message_Msg const &)*arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Root_SendWarning\n * wrapname: _wrap_ShapeFix_Root_SendWarning__SWIG_0\n * fulldecl: void Handle_ShapeFix_Root::SendWarning(TopoDS_Shape const &,Message_Msg const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Root_SendWarning__SWIG_1(Handle_ShapeFix_Root *self,Message_Msg const &message){ + (*self)->SendWarning(message); + } +EXPORT void _wrap_ShapeFix_Root_SendWarning__SWIG_1 (Handle_ShapeFix_Root *larg1, Message_Msg *larg2) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Message_Msg *arg2 = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Root_SendWarning__SWIG_1(arg1,(Message_Msg const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Root_SendWarning\n * wrapname: _wrap_ShapeFix_Root_SendWarning__SWIG_1\n * fulldecl: void Handle_ShapeFix_Root::SendWarning(Message_Msg const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Root_SendFail__SWIG_0(Handle_ShapeFix_Root *self,TopoDS_Shape const &shape,Message_Msg const &message){ + (*self)->SendFail(shape, message); + } +EXPORT void _wrap_ShapeFix_Root_SendFail__SWIG_0 (Handle_ShapeFix_Root *larg1, TopoDS_Shape *larg2, Message_Msg *larg3) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + TopoDS_Shape *arg2 = 0 ; + Message_Msg *arg3 = 0 ; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Root_SendFail__SWIG_0(arg1,(TopoDS_Shape const &)*arg2,(Message_Msg const &)*arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Root_SendFail\n * wrapname: _wrap_ShapeFix_Root_SendFail__SWIG_0\n * fulldecl: void Handle_ShapeFix_Root::SendFail(TopoDS_Shape const &,Message_Msg const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Root_SendFail__SWIG_1(Handle_ShapeFix_Root *self,Message_Msg const &message){ + (*self)->SendFail(message); + } +EXPORT void _wrap_ShapeFix_Root_SendFail__SWIG_1 (Handle_ShapeFix_Root *larg1, Message_Msg *larg2) { + Handle_ShapeFix_Root *arg1 = (Handle_ShapeFix_Root *) 0 ; + Message_Msg *arg2 = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Root_SendFail__SWIG_1(arg1,(Message_Msg const &)*arg2); } catch(Standard_Failure const& error) { @@ -85249,7 +85801,7 @@ EXPORT void _wrap_delete_ShapeFix_Wireframe (ShapeFix_Wireframe *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: delete_ShapeFix_Wireframe\n * wrapname: _wrap_delete_ShapeFix_Wireframe\n * fulldecl: ShapeFix_Wireframe::~ShapeFix_Wireframe()"; + message += "\nwrapper details:\n * symname: ShapeFix_Root_SendFail\n * wrapname: _wrap_ShapeFix_Root_SendFail__SWIG_1\n * fulldecl: void Handle_ShapeFix_Root::SendFail(Message_Msg const &)"; signal_lisp_error(message.c_str()); } } @@ -85260,10 +85812,47 @@ EXPORT void _wrap_delete_ShapeFix_Wireframe (ShapeFix_Wireframe *larg1) { } -EXPORT ShapeFix_Shape *_wrap_new_ShapeFix_Shape (TopoDS_Shape *larg1) { - ShapeFix_Shape * lresult = (ShapeFix_Shape *)0 ; +SWIGINTERN Handle_ShapeFix_Shape *new_Handle_ShapeFix_Shape__SWIG_0(){ + return new Handle_ShapeFix_Shape(new ShapeFix_Shape()); + } +EXPORT Handle_ShapeFix_Shape *_wrap_new_ShapeFix_Shape__SWIG_0 () { + Handle_ShapeFix_Shape * lresult = (Handle_ShapeFix_Shape *)0 ; + Handle_ShapeFix_Shape *result = 0 ; + + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Handle_ShapeFix_Shape *)new_Handle_ShapeFix_Shape__SWIG_0(); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: new_ShapeFix_Shape\n * wrapname: _wrap_new_ShapeFix_Shape__SWIG_0\n * fulldecl: Handle_ShapeFix_Shape::Handle_ShapeFix_Shape()"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Handle_ShapeFix_Shape *)0; + } +} + + +SWIGINTERN Handle_ShapeFix_Shape *new_Handle_ShapeFix_Shape__SWIG_1(TopoDS_Shape const &shape){ + return new Handle_ShapeFix_Shape(new ShapeFix_Shape(shape)); + } +EXPORT Handle_ShapeFix_Shape *_wrap_new_ShapeFix_Shape__SWIG_1 (TopoDS_Shape *larg1) { + Handle_ShapeFix_Shape * lresult = (Handle_ShapeFix_Shape *)0 ; TopoDS_Shape *arg1 = 0 ; - ShapeFix_Shape *result = 0 ; + Handle_ShapeFix_Shape *result = 0 ; arg1 = larg1; try { @@ -85271,7 +85860,7 @@ EXPORT ShapeFix_Shape *_wrap_new_ShapeFix_Shape (TopoDS_Shape *larg1) { try { OCC_CATCH_SIGNALS - result = (ShapeFix_Shape *)new ShapeFix_Shape((TopoDS_Shape const &)*arg1); + result = (Handle_ShapeFix_Shape *)new_Handle_ShapeFix_Shape__SWIG_1((TopoDS_Shape const &)*arg1); } catch(Standard_Failure const& error) { @@ -85281,21 +85870,133 @@ EXPORT ShapeFix_Shape *_wrap_new_ShapeFix_Shape (TopoDS_Shape *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: new_ShapeFix_Shape\n * wrapname: _wrap_new_ShapeFix_Shape\n * fulldecl: ShapeFix_Shape::ShapeFix_Shape(TopoDS_Shape const &)"; + message += "\nwrapper details:\n * symname: new_ShapeFix_Shape\n * wrapname: _wrap_new_ShapeFix_Shape__SWIG_1\n * fulldecl: Handle_ShapeFix_Shape::Handle_ShapeFix_Shape(TopoDS_Shape const &)"; signal_lisp_error(message.c_str()); } } lresult = result; return lresult; } catch (...) { - return (ShapeFix_Shape *)0; + return (Handle_ShapeFix_Shape *)0; + } +} + + +SWIGINTERN void Handle_ShapeFix_Shape_Init(Handle_ShapeFix_Shape *self,TopoDS_Shape const &shape){ + (*self)->Init(shape); + } +EXPORT void _wrap_ShapeFix_Shape_Init (Handle_ShapeFix_Shape *larg1, TopoDS_Shape *larg2) { + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; + TopoDS_Shape *arg2 = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Shape_Init(arg1,(TopoDS_Shape const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Shape_Init\n * wrapname: _wrap_ShapeFix_Shape_Init\n * fulldecl: void Handle_ShapeFix_Shape::Init(TopoDS_Shape const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Shape_Perform__SWIG_0(Handle_ShapeFix_Shape *self){ + return (*self)->Perform(); + } +EXPORT bool _wrap_ShapeFix_Shape_Perform__SWIG_0 (Handle_ShapeFix_Shape *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Shape_Perform__SWIG_0(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Shape_Perform\n * wrapname: _wrap_ShapeFix_Shape_Perform__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Shape::Perform()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Shape_Perform__SWIG_1(Handle_ShapeFix_Shape *self,Handle_Message_ProgressIndicator const &theProgress){ + return (*self)->Perform(theProgress); + } +EXPORT bool _wrap_ShapeFix_Shape_Perform__SWIG_1 (Handle_ShapeFix_Shape *larg1, Handle_Message_ProgressIndicator *larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; + Handle_Message_ProgressIndicator *arg2 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Shape_Perform__SWIG_1(arg1,(Handle_Message_ProgressIndicator const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Shape_Perform\n * wrapname: _wrap_ShapeFix_Shape_Perform__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Shape::Perform(Handle_Message_ProgressIndicator const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; } } -EXPORT TopoDS_Shape *_wrap_ShapeFix_Shape_Shape (ShapeFix_Shape *larg1) { +SWIGINTERN TopoDS_Shape Handle_ShapeFix_Shape_Shape(Handle_ShapeFix_Shape *self){ + return (*self)->Shape(); + } +EXPORT TopoDS_Shape *_wrap_ShapeFix_Shape_Shape (Handle_ShapeFix_Shape *larg1) { TopoDS_Shape * lresult = (TopoDS_Shape *)0 ; - ShapeFix_Shape *arg1 = (ShapeFix_Shape *) 0 ; + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; TopoDS_Shape result; arg1 = larg1; @@ -85304,7 +86005,7 @@ EXPORT TopoDS_Shape *_wrap_ShapeFix_Shape_Shape (ShapeFix_Shape *larg1) { try { OCC_CATCH_SIGNALS - result = ((ShapeFix_Shape const *)arg1)->Shape(); + result = Handle_ShapeFix_Shape_Shape(arg1); } catch(Standard_Failure const& error) { @@ -85314,7 +86015,7 @@ EXPORT TopoDS_Shape *_wrap_ShapeFix_Shape_Shape (ShapeFix_Shape *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Shape_Shape\n * wrapname: _wrap_ShapeFix_Shape_Shape\n * fulldecl: TopoDS_Shape ShapeFix_Shape::Shape() const"; + message += "\nwrapper details:\n * symname: ShapeFix_Shape_Shape\n * wrapname: _wrap_ShapeFix_Shape_Shape\n * fulldecl: TopoDS_Shape Handle_ShapeFix_Shape::Shape()"; signal_lisp_error(message.c_str()); } } @@ -85326,20 +86027,3008 @@ EXPORT TopoDS_Shape *_wrap_ShapeFix_Shape_Shape (ShapeFix_Shape *larg1) { } -EXPORT bool _wrap_ShapeFix_Shape_Perform__SWIG_0 (ShapeFix_Shape *larg1, Handle_Message_ProgressIndicator *larg2) { +SWIGINTERN Handle_ShapeFix_Solid Handle_ShapeFix_Shape_FixSolidTool(Handle_ShapeFix_Shape *self){ + return (*self)->FixSolidTool(); + } +EXPORT Handle_ShapeFix_Solid *_wrap_ShapeFix_Shape_FixSolidTool (Handle_ShapeFix_Shape *larg1) { + Handle_ShapeFix_Solid * lresult = (Handle_ShapeFix_Solid *)0 ; + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; + Handle_ShapeFix_Solid result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Shape_FixSolidTool(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixSolidTool\n * wrapname: _wrap_ShapeFix_Shape_FixSolidTool\n * fulldecl: Handle_ShapeFix_Solid Handle_ShapeFix_Shape::FixSolidTool()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new Handle_ShapeFix_Solid(result); + return lresult; + } catch (...) { + return (Handle_ShapeFix_Solid *)0; + } +} + + +SWIGINTERN Handle_ShapeFix_Shell Handle_ShapeFix_Shape_FixShellTool(Handle_ShapeFix_Shape *self){ + return (*self)->FixShellTool(); + } +EXPORT Handle_ShapeFix_Shell *_wrap_ShapeFix_Shape_FixShellTool (Handle_ShapeFix_Shape *larg1) { + Handle_ShapeFix_Shell * lresult = (Handle_ShapeFix_Shell *)0 ; + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; + Handle_ShapeFix_Shell result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Shape_FixShellTool(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixShellTool\n * wrapname: _wrap_ShapeFix_Shape_FixShellTool\n * fulldecl: Handle_ShapeFix_Shell Handle_ShapeFix_Shape::FixShellTool()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new Handle_ShapeFix_Shell(result); + return lresult; + } catch (...) { + return (Handle_ShapeFix_Shell *)0; + } +} + + +SWIGINTERN Handle_ShapeFix_Face Handle_ShapeFix_Shape_FixFaceTool(Handle_ShapeFix_Shape *self){ + return (*self)->FixFaceTool(); + } +EXPORT Handle_ShapeFix_Face *_wrap_ShapeFix_Shape_FixFaceTool (Handle_ShapeFix_Shape *larg1) { + Handle_ShapeFix_Face * lresult = (Handle_ShapeFix_Face *)0 ; + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; + Handle_ShapeFix_Face result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Shape_FixFaceTool(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixFaceTool\n * wrapname: _wrap_ShapeFix_Shape_FixFaceTool\n * fulldecl: Handle_ShapeFix_Face Handle_ShapeFix_Shape::FixFaceTool()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new Handle_ShapeFix_Face(result); + return lresult; + } catch (...) { + return (Handle_ShapeFix_Face *)0; + } +} + + +SWIGINTERN Handle_ShapeFix_Wire Handle_ShapeFix_Shape_FixWireTool(Handle_ShapeFix_Shape *self){ + return (*self)->FixWireTool(); + } +EXPORT Handle_ShapeFix_Wire *_wrap_ShapeFix_Shape_FixWireTool (Handle_ShapeFix_Shape *larg1) { + Handle_ShapeFix_Wire * lresult = (Handle_ShapeFix_Wire *)0 ; + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; + SwigValueWrapper< Handle_ShapeFix_Wire > result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Shape_FixWireTool(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixWireTool\n * wrapname: _wrap_ShapeFix_Shape_FixWireTool\n * fulldecl: Handle_ShapeFix_Wire Handle_ShapeFix_Shape::FixWireTool()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new Handle_ShapeFix_Wire(result); + return lresult; + } catch (...) { + return (Handle_ShapeFix_Wire *)0; + } +} + + +SWIGINTERN Handle_ShapeFix_Edge Handle_ShapeFix_Shape_FixEdgeTool(Handle_ShapeFix_Shape *self){ + return (*self)->FixEdgeTool(); + } +EXPORT Handle_ShapeFix_Edge *_wrap_ShapeFix_Shape_FixEdgeTool (Handle_ShapeFix_Shape *larg1) { + Handle_ShapeFix_Edge * lresult = (Handle_ShapeFix_Edge *)0 ; + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; + SwigValueWrapper< Handle_ShapeFix_Edge > result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Shape_FixEdgeTool(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixEdgeTool\n * wrapname: _wrap_ShapeFix_Shape_FixEdgeTool\n * fulldecl: Handle_ShapeFix_Edge Handle_ShapeFix_Shape::FixEdgeTool()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new Handle_ShapeFix_Edge(result); + return lresult; + } catch (...) { + return (Handle_ShapeFix_Edge *)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Shape_Status(Handle_ShapeFix_Shape *self,ShapeExtend_Status const status){ + return (*self)->Status(status); + } +EXPORT bool _wrap_ShapeFix_Shape_Status (Handle_ShapeFix_Shape *larg1, ShapeExtend_Status const *larg2) { bool lresult = (bool)0 ; - ShapeFix_Shape *arg1 = (ShapeFix_Shape *) 0 ; - Handle_Message_ProgressIndicator *arg2 = 0 ; + Handle_ShapeFix_Shape *arg1 = (Handle_ShapeFix_Shape *) 0 ; + ShapeExtend_Status arg2 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = *larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Shape_Status(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Shape_Status\n * wrapname: _wrap_ShapeFix_Shape_Status\n * fulldecl: Standard_Boolean Handle_ShapeFix_Shape::Status(ShapeExtend_Status const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Handle_ShapeFix_EdgeProjAux *new_Handle_ShapeFix_EdgeProjAux__SWIG_0(){ + return new Handle_ShapeFix_EdgeProjAux(new ShapeFix_EdgeProjAux()); + } +EXPORT Handle_ShapeFix_EdgeProjAux *_wrap_new_ShapeFix_EdgeProjAux__SWIG_0 () { + Handle_ShapeFix_EdgeProjAux * lresult = (Handle_ShapeFix_EdgeProjAux *)0 ; + Handle_ShapeFix_EdgeProjAux *result = 0 ; + + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Handle_ShapeFix_EdgeProjAux *)new_Handle_ShapeFix_EdgeProjAux__SWIG_0(); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: new_ShapeFix_EdgeProjAux\n * wrapname: _wrap_new_ShapeFix_EdgeProjAux__SWIG_0\n * fulldecl: Handle_ShapeFix_EdgeProjAux::Handle_ShapeFix_EdgeProjAux()"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Handle_ShapeFix_EdgeProjAux *)0; + } +} + + +SWIGINTERN Handle_ShapeFix_EdgeProjAux *new_Handle_ShapeFix_EdgeProjAux__SWIG_1(TopoDS_Face const &F,TopoDS_Edge const &E){ + return new Handle_ShapeFix_EdgeProjAux(new ShapeFix_EdgeProjAux(F, E)); + } +EXPORT Handle_ShapeFix_EdgeProjAux *_wrap_new_ShapeFix_EdgeProjAux__SWIG_1 (TopoDS_Face *larg1, TopoDS_Edge *larg2) { + Handle_ShapeFix_EdgeProjAux * lresult = (Handle_ShapeFix_EdgeProjAux *)0 ; + TopoDS_Face *arg1 = 0 ; + TopoDS_Edge *arg2 = 0 ; + Handle_ShapeFix_EdgeProjAux *result = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Handle_ShapeFix_EdgeProjAux *)new_Handle_ShapeFix_EdgeProjAux__SWIG_1((TopoDS_Face const &)*arg1,(TopoDS_Edge const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: new_ShapeFix_EdgeProjAux\n * wrapname: _wrap_new_ShapeFix_EdgeProjAux__SWIG_1\n * fulldecl: Handle_ShapeFix_EdgeProjAux::Handle_ShapeFix_EdgeProjAux(TopoDS_Face const &,TopoDS_Edge const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Handle_ShapeFix_EdgeProjAux *)0; + } +} + + +SWIGINTERN void Handle_ShapeFix_EdgeProjAux_Delete(Handle_ShapeFix_EdgeProjAux *self){ + self->~Handle_ShapeFix_EdgeProjAux(); + } +EXPORT void _wrap_ShapeFix_EdgeProjAux_Delete (Handle_ShapeFix_EdgeProjAux *larg1) { + Handle_ShapeFix_EdgeProjAux *arg1 = (Handle_ShapeFix_EdgeProjAux *) 0 ; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_EdgeProjAux_Delete(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_EdgeProjAux_Delete\n * wrapname: _wrap_ShapeFix_EdgeProjAux_Delete\n * fulldecl: void Handle_ShapeFix_EdgeProjAux::Delete()"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_EdgeProjAux_Init(Handle_ShapeFix_EdgeProjAux *self,TopoDS_Face const &F,TopoDS_Edge const &E){ + (*self)->Init(F, E); + } +EXPORT void _wrap_ShapeFix_EdgeProjAux_Init (Handle_ShapeFix_EdgeProjAux *larg1, TopoDS_Face *larg2, TopoDS_Edge *larg3) { + Handle_ShapeFix_EdgeProjAux *arg1 = (Handle_ShapeFix_EdgeProjAux *) 0 ; + TopoDS_Face *arg2 = 0 ; + TopoDS_Edge *arg3 = 0 ; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_EdgeProjAux_Init(arg1,(TopoDS_Face const &)*arg2,(TopoDS_Edge const &)*arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_EdgeProjAux_Init\n * wrapname: _wrap_ShapeFix_EdgeProjAux_Init\n * fulldecl: void Handle_ShapeFix_EdgeProjAux::Init(TopoDS_Face const &,TopoDS_Edge const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_EdgeProjAux_Compute(Handle_ShapeFix_EdgeProjAux *self,Standard_Real const preci){ + (*self)->Compute(preci); + } +EXPORT void _wrap_ShapeFix_EdgeProjAux_Compute (Handle_ShapeFix_EdgeProjAux *larg1, Standard_Real larg2) { + Handle_ShapeFix_EdgeProjAux *arg1 = (Handle_ShapeFix_EdgeProjAux *) 0 ; + Standard_Real arg2 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_EdgeProjAux_Compute(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_EdgeProjAux_Compute\n * wrapname: _wrap_ShapeFix_EdgeProjAux_Compute\n * fulldecl: void Handle_ShapeFix_EdgeProjAux::Compute(Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_EdgeProjAux_IsFirstDone(Handle_ShapeFix_EdgeProjAux *self){ + return (*self)->IsFirstDone(); + } +EXPORT bool _wrap_ShapeFix_EdgeProjAux_IsFirstDone (Handle_ShapeFix_EdgeProjAux *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_EdgeProjAux *arg1 = (Handle_ShapeFix_EdgeProjAux *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_EdgeProjAux_IsFirstDone(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_EdgeProjAux_IsFirstDone\n * wrapname: _wrap_ShapeFix_EdgeProjAux_IsFirstDone\n * fulldecl: Standard_Boolean Handle_ShapeFix_EdgeProjAux::IsFirstDone()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_EdgeProjAux_IsLastDone(Handle_ShapeFix_EdgeProjAux *self){ + return (*self)->IsLastDone(); + } +EXPORT bool _wrap_ShapeFix_EdgeProjAux_IsLastDone (Handle_ShapeFix_EdgeProjAux *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_EdgeProjAux *arg1 = (Handle_ShapeFix_EdgeProjAux *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_EdgeProjAux_IsLastDone(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_EdgeProjAux_IsLastDone\n * wrapname: _wrap_ShapeFix_EdgeProjAux_IsLastDone\n * fulldecl: Standard_Boolean Handle_ShapeFix_EdgeProjAux::IsLastDone()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Real Handle_ShapeFix_EdgeProjAux_FirstParam(Handle_ShapeFix_EdgeProjAux *self){ + return (*self)->FirstParam(); + } +EXPORT Standard_Real _wrap_ShapeFix_EdgeProjAux_FirstParam (Handle_ShapeFix_EdgeProjAux *larg1) { + Standard_Real lresult = (Standard_Real)0 ; + Handle_ShapeFix_EdgeProjAux *arg1 = (Handle_ShapeFix_EdgeProjAux *) 0 ; + Standard_Real result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Real)Handle_ShapeFix_EdgeProjAux_FirstParam(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_EdgeProjAux_FirstParam\n * wrapname: _wrap_ShapeFix_EdgeProjAux_FirstParam\n * fulldecl: Standard_Real Handle_ShapeFix_EdgeProjAux::FirstParam()"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Standard_Real)0; + } +} + + +SWIGINTERN Standard_Real Handle_ShapeFix_EdgeProjAux_LastParam(Handle_ShapeFix_EdgeProjAux *self){ + return (*self)->LastParam(); + } +EXPORT Standard_Real _wrap_ShapeFix_EdgeProjAux_LastParam (Handle_ShapeFix_EdgeProjAux *larg1) { + Standard_Real lresult = (Standard_Real)0 ; + Handle_ShapeFix_EdgeProjAux *arg1 = (Handle_ShapeFix_EdgeProjAux *) 0 ; + Standard_Real result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Real)Handle_ShapeFix_EdgeProjAux_LastParam(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_EdgeProjAux_LastParam\n * wrapname: _wrap_ShapeFix_EdgeProjAux_LastParam\n * fulldecl: Standard_Real Handle_ShapeFix_EdgeProjAux::LastParam()"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Standard_Real)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_EdgeProjAux_IsIso(Handle_ShapeFix_EdgeProjAux *self,Handle_Geom2d_Curve const &C){ + return (*self)->IsIso(C); + } +EXPORT bool _wrap_ShapeFix_EdgeProjAux_IsIso (Handle_ShapeFix_EdgeProjAux *larg1, Handle_Geom2d_Curve *larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_EdgeProjAux *arg1 = (Handle_ShapeFix_EdgeProjAux *) 0 ; + Handle_Geom2d_Curve *arg2 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_EdgeProjAux_IsIso(arg1,(Handle_Geom2d_Curve const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_EdgeProjAux_IsIso\n * wrapname: _wrap_ShapeFix_EdgeProjAux_IsIso\n * fulldecl: Standard_Boolean Handle_ShapeFix_EdgeProjAux::IsIso(Handle_Geom2d_Curve const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Handle_ShapeFix_Edge *new_Handle_ShapeFix_Edge(){ + return new Handle_ShapeFix_Edge(new ShapeFix_Edge()); + } +EXPORT Handle_ShapeFix_Edge *_wrap_new_ShapeFix_Edge () { + Handle_ShapeFix_Edge * lresult = (Handle_ShapeFix_Edge *)0 ; + Handle_ShapeFix_Edge *result = 0 ; + + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Handle_ShapeFix_Edge *)new_Handle_ShapeFix_Edge(); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: new_ShapeFix_Edge\n * wrapname: _wrap_new_ShapeFix_Edge\n * fulldecl: Handle_ShapeFix_Edge::Handle_ShapeFix_Edge()"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Handle_ShapeFix_Edge *)0; + } +} + + +SWIGINTERN void Handle_ShapeFix_Edge_Delete(Handle_ShapeFix_Edge *self){ + self->~Handle_ShapeFix_Edge(); + } +EXPORT void _wrap_ShapeFix_Edge_Delete (Handle_ShapeFix_Edge *larg1) { + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Edge_Delete(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_Delete\n * wrapname: _wrap_ShapeFix_Edge_Delete\n * fulldecl: void Handle_ShapeFix_Edge::Delete()"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN Handle_ShapeConstruct_ProjectCurveOnSurface Handle_ShapeFix_Edge_Projector(Handle_ShapeFix_Edge *self){ + return (*self)->Projector(); + } +EXPORT Handle_ShapeConstruct_ProjectCurveOnSurface *_wrap_ShapeFix_Edge_Projector (Handle_ShapeFix_Edge *larg1) { + Handle_ShapeConstruct_ProjectCurveOnSurface * lresult = (Handle_ShapeConstruct_ProjectCurveOnSurface *)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + Handle_ShapeConstruct_ProjectCurveOnSurface result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Edge_Projector(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_Projector\n * wrapname: _wrap_ShapeFix_Edge_Projector\n * fulldecl: Handle_ShapeConstruct_ProjectCurveOnSurface Handle_ShapeFix_Edge::Projector()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new Handle_ShapeConstruct_ProjectCurveOnSurface(result); + return lresult; + } catch (...) { + return (Handle_ShapeConstruct_ProjectCurveOnSurface *)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixRemovePCurve__SWIG_0(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,TopoDS_Face const &face){ + return (*self)->FixRemovePCurve(edge, face); + } +EXPORT bool _wrap_ShapeFix_Edge_FixRemovePCurve__SWIG_0 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, TopoDS_Face *larg3) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixRemovePCurve__SWIG_0(arg1,(TopoDS_Edge const &)*arg2,(TopoDS_Face const &)*arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixRemovePCurve\n * wrapname: _wrap_ShapeFix_Edge_FixRemovePCurve__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixRemovePCurve(TopoDS_Edge const &,TopoDS_Face const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixRemovePCurve__SWIG_1(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,Handle_Geom_Surface const &surface,TopLoc_Location const &location){ + return (*self)->FixRemovePCurve(edge, surface, location); + } +EXPORT bool _wrap_ShapeFix_Edge_FixRemovePCurve__SWIG_1 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, Handle_Geom_Surface *larg3, TopLoc_Location *larg4) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Handle_Geom_Surface *arg3 = 0 ; + TopLoc_Location *arg4 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = larg4; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixRemovePCurve__SWIG_1(arg1,(TopoDS_Edge const &)*arg2,(Handle_Geom_Surface const &)*arg3,(TopLoc_Location const &)*arg4); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixRemovePCurve\n * wrapname: _wrap_ShapeFix_Edge_FixRemovePCurve__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixRemovePCurve(TopoDS_Edge const &,Handle_Geom_Surface const &,TopLoc_Location const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixRemoveCurve3d(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge){ + return (*self)->FixRemoveCurve3d(edge); + } +EXPORT bool _wrap_ShapeFix_Edge_FixRemoveCurve3d (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixRemoveCurve3d(arg1,(TopoDS_Edge const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixRemoveCurve3d\n * wrapname: _wrap_ShapeFix_Edge_FixRemoveCurve3d\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixRemoveCurve3d(TopoDS_Edge const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixAddPCurve__SWIG_0(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,TopoDS_Face const &face,Standard_Boolean const isSeam,Standard_Real const prec=0.0){ + return (*self)->FixAddPCurve(edge, face, isSeam, prec); + } +EXPORT bool _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_0 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, TopoDS_Face *larg3, bool larg4, Standard_Real larg5) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Boolean arg4 ; + Standard_Real arg5 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = (bool)larg4; + arg5 = larg5; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixAddPCurve__SWIG_0(arg1,(TopoDS_Edge const &)*arg2,(TopoDS_Face const &)*arg3,arg4,arg5); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixAddPCurve\n * wrapname: _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixAddPCurve(TopoDS_Edge const &,TopoDS_Face const &,Standard_Boolean const,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_1 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, TopoDS_Face *larg3, bool larg4) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Boolean arg4 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = (bool)larg4; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixAddPCurve__SWIG_0(arg1,(TopoDS_Edge const &)*arg2,(TopoDS_Face const &)*arg3,arg4); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixAddPCurve\n * wrapname: _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixAddPCurve(TopoDS_Edge const &,TopoDS_Face const &,Standard_Boolean const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixAddPCurve__SWIG_2(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,Handle_Geom_Surface const &surface,TopLoc_Location const &location,Standard_Boolean const isSeam,Standard_Real const prec=0.0){ + return (*self)->FixAddPCurve(edge, surface, location, isSeam, prec); + } +EXPORT bool _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_2 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, Handle_Geom_Surface *larg3, TopLoc_Location *larg4, bool larg5, Standard_Real larg6) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Handle_Geom_Surface *arg3 = 0 ; + TopLoc_Location *arg4 = 0 ; + Standard_Boolean arg5 ; + Standard_Real arg6 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = larg4; + arg5 = (bool)larg5; + arg6 = larg6; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixAddPCurve__SWIG_2(arg1,(TopoDS_Edge const &)*arg2,(Handle_Geom_Surface const &)*arg3,(TopLoc_Location const &)*arg4,arg5,arg6); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixAddPCurve\n * wrapname: _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_2\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixAddPCurve(TopoDS_Edge const &,Handle_Geom_Surface const &,TopLoc_Location const &,Standard_Boolean const,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_3 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, Handle_Geom_Surface *larg3, TopLoc_Location *larg4, bool larg5) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Handle_Geom_Surface *arg3 = 0 ; + TopLoc_Location *arg4 = 0 ; + Standard_Boolean arg5 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = larg4; + arg5 = (bool)larg5; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixAddPCurve__SWIG_2(arg1,(TopoDS_Edge const &)*arg2,(Handle_Geom_Surface const &)*arg3,(TopLoc_Location const &)*arg4,arg5); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixAddPCurve\n * wrapname: _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_3\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixAddPCurve(TopoDS_Edge const &,Handle_Geom_Surface const &,TopLoc_Location const &,Standard_Boolean const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixAddPCurve__SWIG_4(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,TopoDS_Face const &face,Standard_Boolean const isSeam,Handle_ShapeAnalysis_Surface const &surfana,Standard_Real const prec=0.0){ + return (*self)->FixAddPCurve(edge, face, isSeam, surfana, prec); + } +EXPORT bool _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_4 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, TopoDS_Face *larg3, bool larg4, Handle_ShapeAnalysis_Surface *larg5, Standard_Real larg6) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Boolean arg4 ; + Handle_ShapeAnalysis_Surface *arg5 = 0 ; + Standard_Real arg6 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = (bool)larg4; + arg5 = larg5; + arg6 = larg6; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixAddPCurve__SWIG_4(arg1,(TopoDS_Edge const &)*arg2,(TopoDS_Face const &)*arg3,arg4,(Handle_ShapeAnalysis_Surface const &)*arg5,arg6); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixAddPCurve\n * wrapname: _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_4\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixAddPCurve(TopoDS_Edge const &,TopoDS_Face const &,Standard_Boolean const,Handle_ShapeAnalysis_Surface const &,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_5 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, TopoDS_Face *larg3, bool larg4, Handle_ShapeAnalysis_Surface *larg5) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Boolean arg4 ; + Handle_ShapeAnalysis_Surface *arg5 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = (bool)larg4; + arg5 = larg5; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixAddPCurve__SWIG_4(arg1,(TopoDS_Edge const &)*arg2,(TopoDS_Face const &)*arg3,arg4,(Handle_ShapeAnalysis_Surface const &)*arg5); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixAddPCurve\n * wrapname: _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_5\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixAddPCurve(TopoDS_Edge const &,TopoDS_Face const &,Standard_Boolean const,Handle_ShapeAnalysis_Surface const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixAddPCurve__SWIG_6(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,Handle_Geom_Surface const &surface,TopLoc_Location const &location,Standard_Boolean const isSeam,Handle_ShapeAnalysis_Surface const &surfana,Standard_Real const prec=0.0){ + return (*self)->FixAddPCurve(edge, surface, location, isSeam, surfana, prec); + } +EXPORT bool _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_6 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, Handle_Geom_Surface *larg3, TopLoc_Location *larg4, bool larg5, Handle_ShapeAnalysis_Surface *larg6, Standard_Real larg7) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Handle_Geom_Surface *arg3 = 0 ; + TopLoc_Location *arg4 = 0 ; + Standard_Boolean arg5 ; + Handle_ShapeAnalysis_Surface *arg6 = 0 ; + Standard_Real arg7 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = larg4; + arg5 = (bool)larg5; + arg6 = larg6; + arg7 = larg7; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixAddPCurve__SWIG_6(arg1,(TopoDS_Edge const &)*arg2,(Handle_Geom_Surface const &)*arg3,(TopLoc_Location const &)*arg4,arg5,(Handle_ShapeAnalysis_Surface const &)*arg6,arg7); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixAddPCurve\n * wrapname: _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_6\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixAddPCurve(TopoDS_Edge const &,Handle_Geom_Surface const &,TopLoc_Location const &,Standard_Boolean const,Handle_ShapeAnalysis_Surface const &,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_7 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, Handle_Geom_Surface *larg3, TopLoc_Location *larg4, bool larg5, Handle_ShapeAnalysis_Surface *larg6) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Handle_Geom_Surface *arg3 = 0 ; + TopLoc_Location *arg4 = 0 ; + Standard_Boolean arg5 ; + Handle_ShapeAnalysis_Surface *arg6 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = larg4; + arg5 = (bool)larg5; + arg6 = larg6; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixAddPCurve__SWIG_6(arg1,(TopoDS_Edge const &)*arg2,(Handle_Geom_Surface const &)*arg3,(TopLoc_Location const &)*arg4,arg5,(Handle_ShapeAnalysis_Surface const &)*arg6); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixAddPCurve\n * wrapname: _wrap_ShapeFix_Edge_FixAddPCurve__SWIG_7\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixAddPCurve(TopoDS_Edge const &,Handle_Geom_Surface const &,TopLoc_Location const &,Standard_Boolean const,Handle_ShapeAnalysis_Surface const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixAddCurve3d(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge){ + return (*self)->FixAddCurve3d(edge); + } +EXPORT bool _wrap_ShapeFix_Edge_FixAddCurve3d (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixAddCurve3d(arg1,(TopoDS_Edge const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixAddCurve3d\n * wrapname: _wrap_ShapeFix_Edge_FixAddCurve3d\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixAddCurve3d(TopoDS_Edge const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixVertexTolerance__SWIG_0(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,TopoDS_Face const &face){ + return (*self)->FixVertexTolerance(edge, face); + } +EXPORT bool _wrap_ShapeFix_Edge_FixVertexTolerance__SWIG_0 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, TopoDS_Face *larg3) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixVertexTolerance__SWIG_0(arg1,(TopoDS_Edge const &)*arg2,(TopoDS_Face const &)*arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixVertexTolerance\n * wrapname: _wrap_ShapeFix_Edge_FixVertexTolerance__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixVertexTolerance(TopoDS_Edge const &,TopoDS_Face const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixVertexTolerance__SWIG_1(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge){ + return (*self)->FixVertexTolerance(edge); + } +EXPORT bool _wrap_ShapeFix_Edge_FixVertexTolerance__SWIG_1 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixVertexTolerance__SWIG_1(arg1,(TopoDS_Edge const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixVertexTolerance\n * wrapname: _wrap_ShapeFix_Edge_FixVertexTolerance__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixVertexTolerance(TopoDS_Edge const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixReversed2d__SWIG_0(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,TopoDS_Face const &face){ + return (*self)->FixReversed2d(edge, face); + } +EXPORT bool _wrap_ShapeFix_Edge_FixReversed2d__SWIG_0 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, TopoDS_Face *larg3) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixReversed2d__SWIG_0(arg1,(TopoDS_Edge const &)*arg2,(TopoDS_Face const &)*arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixReversed2d\n * wrapname: _wrap_ShapeFix_Edge_FixReversed2d__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixReversed2d(TopoDS_Edge const &,TopoDS_Face const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixReversed2d__SWIG_1(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,Handle_Geom_Surface const &surface,TopLoc_Location const &location){ + return (*self)->FixReversed2d(edge, surface, location); + } +EXPORT bool _wrap_ShapeFix_Edge_FixReversed2d__SWIG_1 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, Handle_Geom_Surface *larg3, TopLoc_Location *larg4) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Handle_Geom_Surface *arg3 = 0 ; + TopLoc_Location *arg4 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = larg4; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixReversed2d__SWIG_1(arg1,(TopoDS_Edge const &)*arg2,(Handle_Geom_Surface const &)*arg3,(TopLoc_Location const &)*arg4); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixReversed2d\n * wrapname: _wrap_ShapeFix_Edge_FixReversed2d__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixReversed2d(TopoDS_Edge const &,Handle_Geom_Surface const &,TopLoc_Location const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixSameParameter__SWIG_0(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,Standard_Real const tolerance=0.0){ + return (*self)->FixSameParameter(edge, tolerance); + } +EXPORT bool _wrap_ShapeFix_Edge_FixSameParameter__SWIG_0 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, Standard_Real larg3) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Standard_Real arg3 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixSameParameter__SWIG_0(arg1,(TopoDS_Edge const &)*arg2,arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixSameParameter\n * wrapname: _wrap_ShapeFix_Edge_FixSameParameter__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixSameParameter(TopoDS_Edge const &,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Edge_FixSameParameter__SWIG_1 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixSameParameter__SWIG_0(arg1,(TopoDS_Edge const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixSameParameter\n * wrapname: _wrap_ShapeFix_Edge_FixSameParameter__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixSameParameter(TopoDS_Edge const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_FixSameParameter__SWIG_2(Handle_ShapeFix_Edge *self,TopoDS_Edge const &edge,TopoDS_Face const &face,Standard_Real const tolerance=0.0){ + return (*self)->FixSameParameter(edge, face, tolerance); + } +EXPORT bool _wrap_ShapeFix_Edge_FixSameParameter__SWIG_2 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, TopoDS_Face *larg3, Standard_Real larg4) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Real arg4 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = larg4; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixSameParameter__SWIG_2(arg1,(TopoDS_Edge const &)*arg2,(TopoDS_Face const &)*arg3,arg4); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixSameParameter\n * wrapname: _wrap_ShapeFix_Edge_FixSameParameter__SWIG_2\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixSameParameter(TopoDS_Edge const &,TopoDS_Face const &,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Edge_FixSameParameter__SWIG_3 (Handle_ShapeFix_Edge *larg1, TopoDS_Edge *larg2, TopoDS_Face *larg3) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + TopoDS_Edge *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_FixSameParameter__SWIG_2(arg1,(TopoDS_Edge const &)*arg2,(TopoDS_Face const &)*arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_FixSameParameter\n * wrapname: _wrap_ShapeFix_Edge_FixSameParameter__SWIG_3\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::FixSameParameter(TopoDS_Edge const &,TopoDS_Face const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Edge_Status(Handle_ShapeFix_Edge *self,ShapeExtend_Status const status){ + return (*self)->Status(status); + } +EXPORT bool _wrap_ShapeFix_Edge_Status (Handle_ShapeFix_Edge *larg1, ShapeExtend_Status const *larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + ShapeExtend_Status arg2 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = *larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Edge_Status(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_Status\n * wrapname: _wrap_ShapeFix_Edge_Status\n * fulldecl: Standard_Boolean Handle_ShapeFix_Edge::Status(ShapeExtend_Status const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN void Handle_ShapeFix_Edge_SetContext(Handle_ShapeFix_Edge *self,Handle_ShapeBuild_ReShape const &context){ + (*self)->SetContext(context); + } +EXPORT void _wrap_ShapeFix_Edge_SetContext (Handle_ShapeFix_Edge *larg1, Handle_ShapeBuild_ReShape *larg2) { + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + Handle_ShapeBuild_ReShape *arg2 = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Edge_SetContext(arg1,(Handle_ShapeBuild_ReShape const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_SetContext\n * wrapname: _wrap_ShapeFix_Edge_SetContext\n * fulldecl: void Handle_ShapeFix_Edge::SetContext(Handle_ShapeBuild_ReShape const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN Handle_ShapeBuild_ReShape Handle_ShapeFix_Edge_Context(Handle_ShapeFix_Edge *self){ + return (*self)->Context(); + } +EXPORT Handle_ShapeBuild_ReShape *_wrap_ShapeFix_Edge_Context (Handle_ShapeFix_Edge *larg1) { + Handle_ShapeBuild_ReShape * lresult = (Handle_ShapeBuild_ReShape *)0 ; + Handle_ShapeFix_Edge *arg1 = (Handle_ShapeFix_Edge *) 0 ; + Handle_ShapeBuild_ReShape result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Edge_Context(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Edge_Context\n * wrapname: _wrap_ShapeFix_Edge_Context\n * fulldecl: Handle_ShapeBuild_ReShape Handle_ShapeFix_Edge::Context()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new Handle_ShapeBuild_ReShape(result); + return lresult; + } catch (...) { + return (Handle_ShapeBuild_ReShape *)0; + } +} + + +SWIGINTERN Handle_ShapeFix_Wire *new_Handle_ShapeFix_Wire__SWIG_0(){ + return new Handle_ShapeFix_Wire(new ShapeFix_Wire()); + } +EXPORT Handle_ShapeFix_Wire *_wrap_new_ShapeFix_Wire__SWIG_0 () { + Handle_ShapeFix_Wire * lresult = (Handle_ShapeFix_Wire *)0 ; + Handle_ShapeFix_Wire *result = 0 ; + + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Handle_ShapeFix_Wire *)new_Handle_ShapeFix_Wire__SWIG_0(); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: new_ShapeFix_Wire\n * wrapname: _wrap_new_ShapeFix_Wire__SWIG_0\n * fulldecl: Handle_ShapeFix_Wire::Handle_ShapeFix_Wire()"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Handle_ShapeFix_Wire *)0; + } +} + + +SWIGINTERN Handle_ShapeFix_Wire *new_Handle_ShapeFix_Wire__SWIG_1(TopoDS_Wire const &wire,TopoDS_Face const &face,Standard_Real const prec){ + return new Handle_ShapeFix_Wire(new ShapeFix_Wire(wire, face, prec)); + } +EXPORT Handle_ShapeFix_Wire *_wrap_new_ShapeFix_Wire__SWIG_1 (TopoDS_Wire *larg1, TopoDS_Face *larg2, Standard_Real larg3) { + Handle_ShapeFix_Wire * lresult = (Handle_ShapeFix_Wire *)0 ; + TopoDS_Wire *arg1 = 0 ; + TopoDS_Face *arg2 = 0 ; + Standard_Real arg3 ; + Handle_ShapeFix_Wire *result = 0 ; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Handle_ShapeFix_Wire *)new_Handle_ShapeFix_Wire__SWIG_1((TopoDS_Wire const &)*arg1,(TopoDS_Face const &)*arg2,arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: new_ShapeFix_Wire\n * wrapname: _wrap_new_ShapeFix_Wire__SWIG_1\n * fulldecl: Handle_ShapeFix_Wire::Handle_ShapeFix_Wire(TopoDS_Wire const &,TopoDS_Face const &,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Handle_ShapeFix_Wire *)0; + } +} + + +SWIGINTERN void Handle_ShapeFix_Wire_Delete(Handle_ShapeFix_Wire *self){ + self->~Handle_ShapeFix_Wire(); + } +EXPORT void _wrap_ShapeFix_Wire_Delete (Handle_ShapeFix_Wire *larg1) { + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wire_Delete(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_Delete\n * wrapname: _wrap_ShapeFix_Wire_Delete\n * fulldecl: void Handle_ShapeFix_Wire::Delete()"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Wire_ClearModes(Handle_ShapeFix_Wire *self){ + (*self)->ClearModes(); + } +EXPORT void _wrap_ShapeFix_Wire_ClearModes (Handle_ShapeFix_Wire *larg1) { + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wire_ClearModes(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_ClearModes\n * wrapname: _wrap_ShapeFix_Wire_ClearModes\n * fulldecl: void Handle_ShapeFix_Wire::ClearModes()"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Wire_ClearStatuses(Handle_ShapeFix_Wire *self){ + (*self)->ClearStatuses(); + } +EXPORT void _wrap_ShapeFix_Wire_ClearStatuses (Handle_ShapeFix_Wire *larg1) { + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wire_ClearStatuses(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_ClearStatuses\n * wrapname: _wrap_ShapeFix_Wire_ClearStatuses\n * fulldecl: void Handle_ShapeFix_Wire::ClearStatuses()"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Wire_Init__SWIG_0(Handle_ShapeFix_Wire *self,TopoDS_Wire const &wire,TopoDS_Face const &face,Standard_Real const prec){ + (*self)->Init(wire, face, prec); + } +EXPORT void _wrap_ShapeFix_Wire_Init__SWIG_0 (Handle_ShapeFix_Wire *larg1, TopoDS_Wire *larg2, TopoDS_Face *larg3, Standard_Real larg4) { + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + TopoDS_Wire *arg2 = 0 ; + TopoDS_Face *arg3 = 0 ; + Standard_Real arg4 ; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + arg4 = larg4; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wire_Init__SWIG_0(arg1,(TopoDS_Wire const &)*arg2,(TopoDS_Face const &)*arg3,arg4); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_Init\n * wrapname: _wrap_ShapeFix_Wire_Init__SWIG_0\n * fulldecl: void Handle_ShapeFix_Wire::Init(TopoDS_Wire const &,TopoDS_Face const &,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Wire_Init__SWIG_1(Handle_ShapeFix_Wire *self,Handle_ShapeAnalysis_Wire const &saw){ + (*self)->Init(saw); + } +EXPORT void _wrap_ShapeFix_Wire_Init__SWIG_1 (Handle_ShapeFix_Wire *larg1, Handle_ShapeAnalysis_Wire *larg2) { + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Handle_ShapeAnalysis_Wire *arg2 = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wire_Init__SWIG_1(arg1,(Handle_ShapeAnalysis_Wire const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_Init\n * wrapname: _wrap_ShapeFix_Wire_Init__SWIG_1\n * fulldecl: void Handle_ShapeFix_Wire::Init(Handle_ShapeAnalysis_Wire const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Wire_Load__SWIG_0(Handle_ShapeFix_Wire *self,TopoDS_Wire const &wire){ + (*self)->Load(wire); + } +EXPORT void _wrap_ShapeFix_Wire_Load__SWIG_0 (Handle_ShapeFix_Wire *larg1, TopoDS_Wire *larg2) { + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + TopoDS_Wire *arg2 = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wire_Load__SWIG_0(arg1,(TopoDS_Wire const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_Load\n * wrapname: _wrap_ShapeFix_Wire_Load__SWIG_0\n * fulldecl: void Handle_ShapeFix_Wire::Load(TopoDS_Wire const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Wire_Load__SWIG_1(Handle_ShapeFix_Wire *self,Handle_ShapeExtend_WireData const &sbwd){ + (*self)->Load(sbwd); + } +EXPORT void _wrap_ShapeFix_Wire_Load__SWIG_1 (Handle_ShapeFix_Wire *larg1, Handle_ShapeExtend_WireData *larg2) { + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Handle_ShapeExtend_WireData *arg2 = 0 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wire_Load__SWIG_1(arg1,(Handle_ShapeExtend_WireData const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_Load\n * wrapname: _wrap_ShapeFix_Wire_Load__SWIG_1\n * fulldecl: void Handle_ShapeFix_Wire::Load(Handle_ShapeExtend_WireData const &)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Wire_SetMaxTailAngle(Handle_ShapeFix_Wire *self,Standard_Real const theMaxTailAngle){ + (*self)->SetMaxTailAngle(theMaxTailAngle); + } +EXPORT void _wrap_ShapeFix_Wire_SetMaxTailAngle (Handle_ShapeFix_Wire *larg1, Standard_Real larg2) { + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Real arg2 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wire_SetMaxTailAngle(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_SetMaxTailAngle\n * wrapname: _wrap_ShapeFix_Wire_SetMaxTailAngle\n * fulldecl: void Handle_ShapeFix_Wire::SetMaxTailAngle(Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN void Handle_ShapeFix_Wire_SetMaxTailWidth(Handle_ShapeFix_Wire *self,Standard_Real const theMaxTailWidth){ + (*self)->SetMaxTailWidth(theMaxTailWidth); + } +EXPORT void _wrap_ShapeFix_Wire_SetMaxTailWidth (Handle_ShapeFix_Wire *larg1, Standard_Real larg2) { + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Real arg2 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wire_SetMaxTailWidth(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_SetMaxTailWidth\n * wrapname: _wrap_ShapeFix_Wire_SetMaxTailWidth\n * fulldecl: void Handle_ShapeFix_Wire::SetMaxTailWidth(Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + + } catch (...) { + + } +} + + +SWIGINTERN Standard_Integer Handle_ShapeFix_Wire_NbEdges(Handle_ShapeFix_Wire *self){ + return (*self)->NbEdges(); + } +EXPORT Standard_Integer _wrap_ShapeFix_Wire_NbEdges (Handle_ShapeFix_Wire *larg1) { + Standard_Integer lresult = (Standard_Integer)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Integer)Handle_ShapeFix_Wire_NbEdges(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_NbEdges\n * wrapname: _wrap_ShapeFix_Wire_NbEdges\n * fulldecl: Standard_Integer Handle_ShapeFix_Wire::NbEdges()"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Standard_Integer)0; + } +} + + +SWIGINTERN TopoDS_Wire Handle_ShapeFix_Wire_Wire(Handle_ShapeFix_Wire *self){ + return (*self)->Wire(); + } +EXPORT TopoDS_Wire *_wrap_ShapeFix_Wire_Wire (Handle_ShapeFix_Wire *larg1) { + TopoDS_Wire * lresult = (TopoDS_Wire *)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + TopoDS_Wire result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Wire_Wire(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_Wire\n * wrapname: _wrap_ShapeFix_Wire_Wire\n * fulldecl: TopoDS_Wire Handle_ShapeFix_Wire::Wire()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new TopoDS_Wire(result); + return lresult; + } catch (...) { + return (TopoDS_Wire *)0; + } +} + + +SWIGINTERN TopoDS_Wire Handle_ShapeFix_Wire_WireAPIMake(Handle_ShapeFix_Wire *self){ + return (*self)->WireAPIMake(); + } +EXPORT TopoDS_Wire *_wrap_ShapeFix_Wire_WireAPIMake (Handle_ShapeFix_Wire *larg1) { + TopoDS_Wire * lresult = (TopoDS_Wire *)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + TopoDS_Wire result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Wire_WireAPIMake(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_WireAPIMake\n * wrapname: _wrap_ShapeFix_Wire_WireAPIMake\n * fulldecl: TopoDS_Wire Handle_ShapeFix_Wire::WireAPIMake()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new TopoDS_Wire(result); + return lresult; + } catch (...) { + return (TopoDS_Wire *)0; + } +} + + +SWIGINTERN Handle_ShapeAnalysis_Wire Handle_ShapeFix_Wire_Analyzer(Handle_ShapeFix_Wire *self){ + return (*self)->Analyzer(); + } +EXPORT Handle_ShapeAnalysis_Wire *_wrap_ShapeFix_Wire_Analyzer (Handle_ShapeFix_Wire *larg1) { + Handle_ShapeAnalysis_Wire * lresult = (Handle_ShapeAnalysis_Wire *)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Handle_ShapeAnalysis_Wire result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Wire_Analyzer(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_Analyzer\n * wrapname: _wrap_ShapeFix_Wire_Analyzer\n * fulldecl: Handle_ShapeAnalysis_Wire Handle_ShapeFix_Wire::Analyzer()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new Handle_ShapeAnalysis_Wire(result); + return lresult; + } catch (...) { + return (Handle_ShapeAnalysis_Wire *)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_Perform(Handle_ShapeFix_Wire *self){ + return (*self)->Perform(); + } +EXPORT bool _wrap_ShapeFix_Wire_Perform (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_Perform(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_Perform\n * wrapname: _wrap_ShapeFix_Wire_Perform\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::Perform()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixReorder__SWIG_0(Handle_ShapeFix_Wire *self){ + return (*self)->FixReorder(); + } +EXPORT bool _wrap_ShapeFix_Wire_FixReorder__SWIG_0 (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixReorder__SWIG_0(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixReorder\n * wrapname: _wrap_ShapeFix_Wire_FixReorder__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixReorder()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Integer Handle_ShapeFix_Wire_FixSmall__SWIG_0(Handle_ShapeFix_Wire *self,Standard_Boolean const lockvtx,Standard_Real const precsmall=0.0){ + return (*self)->FixSmall(lockvtx, precsmall); + } +EXPORT Standard_Integer _wrap_ShapeFix_Wire_FixSmall__SWIG_0 (Handle_ShapeFix_Wire *larg1, bool larg2, Standard_Real larg3) { + Standard_Integer lresult = (Standard_Integer)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean arg2 ; + Standard_Real arg3 ; + Standard_Integer result; + + arg1 = larg1; + arg2 = (bool)larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Integer)Handle_ShapeFix_Wire_FixSmall__SWIG_0(arg1,arg2,arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixSmall\n * wrapname: _wrap_ShapeFix_Wire_FixSmall__SWIG_0\n * fulldecl: Standard_Integer Handle_ShapeFix_Wire::FixSmall(Standard_Boolean const,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Standard_Integer)0; + } +} + + +EXPORT Standard_Integer _wrap_ShapeFix_Wire_FixSmall__SWIG_1 (Handle_ShapeFix_Wire *larg1, bool larg2) { + Standard_Integer lresult = (Standard_Integer)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean arg2 ; + Standard_Integer result; + + arg1 = larg1; + arg2 = (bool)larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Integer)Handle_ShapeFix_Wire_FixSmall__SWIG_0(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixSmall\n * wrapname: _wrap_ShapeFix_Wire_FixSmall__SWIG_1\n * fulldecl: Standard_Integer Handle_ShapeFix_Wire::FixSmall(Standard_Boolean const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Standard_Integer)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixConnected__SWIG_0(Handle_ShapeFix_Wire *self,Standard_Real const prec=-1.0){ + return (*self)->FixConnected(prec); + } +EXPORT bool _wrap_ShapeFix_Wire_FixConnected__SWIG_0 (Handle_ShapeFix_Wire *larg1, Standard_Real larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Real arg2 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixConnected__SWIG_0(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixConnected\n * wrapname: _wrap_ShapeFix_Wire_FixConnected__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixConnected(Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Wire_FixConnected__SWIG_1 (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixConnected__SWIG_0(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixConnected\n * wrapname: _wrap_ShapeFix_Wire_FixConnected__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixConnected()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixEdgeCurves(Handle_ShapeFix_Wire *self){ + return (*self)->FixEdgeCurves(); + } +EXPORT bool _wrap_ShapeFix_Wire_FixEdgeCurves (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixEdgeCurves(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixEdgeCurves\n * wrapname: _wrap_ShapeFix_Wire_FixEdgeCurves\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixEdgeCurves()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixDegenerated__SWIG_0(Handle_ShapeFix_Wire *self){ + return (*self)->FixDegenerated(); + } +EXPORT bool _wrap_ShapeFix_Wire_FixDegenerated__SWIG_0 (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixDegenerated__SWIG_0(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixDegenerated\n * wrapname: _wrap_ShapeFix_Wire_FixDegenerated__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixDegenerated()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixSelfIntersection(Handle_ShapeFix_Wire *self){ + return (*self)->FixSelfIntersection(); + } +EXPORT bool _wrap_ShapeFix_Wire_FixSelfIntersection (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixSelfIntersection(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixSelfIntersection\n * wrapname: _wrap_ShapeFix_Wire_FixSelfIntersection\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixSelfIntersection()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixLacking__SWIG_0(Handle_ShapeFix_Wire *self,Standard_Boolean const force=Standard_False){ + return (*self)->FixLacking(force); + } +EXPORT bool _wrap_ShapeFix_Wire_FixLacking__SWIG_0 (Handle_ShapeFix_Wire *larg1, bool larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean arg2 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = (bool)larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixLacking__SWIG_0(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixLacking\n * wrapname: _wrap_ShapeFix_Wire_FixLacking__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixLacking(Standard_Boolean const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Wire_FixLacking__SWIG_1 (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixLacking__SWIG_0(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixLacking\n * wrapname: _wrap_ShapeFix_Wire_FixLacking__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixLacking()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixClosed__SWIG_0(Handle_ShapeFix_Wire *self,Standard_Real const prec=-1.0){ + return (*self)->FixClosed(prec); + } +EXPORT bool _wrap_ShapeFix_Wire_FixClosed__SWIG_0 (Handle_ShapeFix_Wire *larg1, Standard_Real larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Real arg2 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixClosed__SWIG_0(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixClosed\n * wrapname: _wrap_ShapeFix_Wire_FixClosed__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixClosed(Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Wire_FixClosed__SWIG_1 (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixClosed__SWIG_0(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixClosed\n * wrapname: _wrap_ShapeFix_Wire_FixClosed__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixClosed()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixGaps3d(Handle_ShapeFix_Wire *self){ + return (*self)->FixGaps3d(); + } +EXPORT bool _wrap_ShapeFix_Wire_FixGaps3d (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixGaps3d(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixGaps3d\n * wrapname: _wrap_ShapeFix_Wire_FixGaps3d\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixGaps3d()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixGaps2d(Handle_ShapeFix_Wire *self){ + return (*self)->FixGaps2d(); + } +EXPORT bool _wrap_ShapeFix_Wire_FixGaps2d (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixGaps2d(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixGaps2d\n * wrapname: _wrap_ShapeFix_Wire_FixGaps2d\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixGaps2d()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixReorder__SWIG_1(Handle_ShapeFix_Wire *self,ShapeAnalysis_WireOrder const &wi){ + return (*self)->FixReorder(wi); + } +EXPORT bool _wrap_ShapeFix_Wire_FixReorder__SWIG_1 (Handle_ShapeFix_Wire *larg1, ShapeAnalysis_WireOrder *larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + ShapeAnalysis_WireOrder *arg2 = 0 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixReorder__SWIG_1(arg1,(ShapeAnalysis_WireOrder const &)*arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixReorder\n * wrapname: _wrap_ShapeFix_Wire_FixReorder__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixReorder(ShapeAnalysis_WireOrder const &)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixSmall__SWIG_2(Handle_ShapeFix_Wire *self,Standard_Integer const num,Standard_Boolean const lockvtx,Standard_Real const precsmall){ + return (*self)->FixSmall(num, lockvtx, precsmall); + } +EXPORT bool _wrap_ShapeFix_Wire_FixSmall__SWIG_2 (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2, bool larg3, Standard_Real larg4) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Boolean arg3 ; + Standard_Real arg4 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = (bool)larg3; + arg4 = larg4; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixSmall__SWIG_2(arg1,arg2,arg3,arg4); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixSmall\n * wrapname: _wrap_ShapeFix_Wire_FixSmall__SWIG_2\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixSmall(Standard_Integer const,Standard_Boolean const,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixConnected__SWIG_2(Handle_ShapeFix_Wire *self,Standard_Integer const num,Standard_Real const prec){ + return (*self)->FixConnected(num, prec); + } +EXPORT bool _wrap_ShapeFix_Wire_FixConnected__SWIG_2 (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2, Standard_Real larg3) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Real arg3 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixConnected__SWIG_2(arg1,arg2,arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixConnected\n * wrapname: _wrap_ShapeFix_Wire_FixConnected__SWIG_2\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixConnected(Standard_Integer const,Standard_Real const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixSeam(Handle_ShapeFix_Wire *self,Standard_Integer const num){ + return (*self)->FixSeam(num); + } +EXPORT bool _wrap_ShapeFix_Wire_FixSeam (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixSeam(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixSeam\n * wrapname: _wrap_ShapeFix_Wire_FixSeam\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixSeam(Standard_Integer const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixShifted(Handle_ShapeFix_Wire *self){ + return (*self)->FixShifted(); + } +EXPORT bool _wrap_ShapeFix_Wire_FixShifted (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixShifted(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixShifted\n * wrapname: _wrap_ShapeFix_Wire_FixShifted\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixShifted()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixDegenerated__SWIG_1(Handle_ShapeFix_Wire *self,Standard_Integer const num){ + return (*self)->FixDegenerated(num); + } +EXPORT bool _wrap_ShapeFix_Wire_FixDegenerated__SWIG_1 (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixDegenerated__SWIG_1(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixDegenerated\n * wrapname: _wrap_ShapeFix_Wire_FixDegenerated__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixDegenerated(Standard_Integer const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixLacking__SWIG_2(Handle_ShapeFix_Wire *self,Standard_Integer const num,Standard_Boolean const force=Standard_False){ + return (*self)->FixLacking(num, force); + } +EXPORT bool _wrap_ShapeFix_Wire_FixLacking__SWIG_2 (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2, bool larg3) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Boolean arg3 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + arg3 = (bool)larg3; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixLacking__SWIG_2(arg1,arg2,arg3); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixLacking\n * wrapname: _wrap_ShapeFix_Wire_FixLacking__SWIG_2\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixLacking(Standard_Integer const,Standard_Boolean const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +EXPORT bool _wrap_ShapeFix_Wire_FixLacking__SWIG_3 (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Boolean result; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixLacking__SWIG_2(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixLacking\n * wrapname: _wrap_ShapeFix_Wire_FixLacking__SWIG_3\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixLacking(Standard_Integer const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixNotchedEdges(Handle_ShapeFix_Wire *self){ + return (*self)->FixNotchedEdges(); + } +EXPORT bool _wrap_ShapeFix_Wire_FixNotchedEdges (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; Standard_Boolean result; arg1 = larg1; - arg2 = larg2; try { { try { OCC_CATCH_SIGNALS - result = (Standard_Boolean)(arg1)->Perform((Handle_Message_ProgressIndicator const &)*arg2); + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixNotchedEdges(arg1); } catch(Standard_Failure const& error) { @@ -85349,7 +89038,7 @@ EXPORT bool _wrap_ShapeFix_Shape_Perform__SWIG_0 (ShapeFix_Shape *larg1, Handle_ if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Shape_Perform\n * wrapname: _wrap_ShapeFix_Shape_Perform__SWIG_0\n * fulldecl: Standard_Boolean ShapeFix_Shape::Perform(Handle_Message_ProgressIndicator const &)"; + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixNotchedEdges\n * wrapname: _wrap_ShapeFix_Wire_FixNotchedEdges\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixNotchedEdges()"; signal_lisp_error(message.c_str()); } } @@ -85361,18 +89050,25 @@ EXPORT bool _wrap_ShapeFix_Shape_Perform__SWIG_0 (ShapeFix_Shape *larg1, Handle_ } -EXPORT bool _wrap_ShapeFix_Shape_Perform__SWIG_1 (ShapeFix_Shape *larg1) { +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixGap3d__SWIG_0(Handle_ShapeFix_Wire *self,Standard_Integer const num,Standard_Boolean const convert=Standard_False){ + return (*self)->FixGap3d(num, convert); + } +EXPORT bool _wrap_ShapeFix_Wire_FixGap3d__SWIG_0 (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2, bool larg3) { bool lresult = (bool)0 ; - ShapeFix_Shape *arg1 = (ShapeFix_Shape *) 0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Boolean arg3 ; Standard_Boolean result; arg1 = larg1; + arg2 = larg2; + arg3 = (bool)larg3; try { { try { OCC_CATCH_SIGNALS - result = (Standard_Boolean)(arg1)->Perform(); + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixGap3d__SWIG_0(arg1,arg2,arg3); } catch(Standard_Failure const& error) { @@ -85382,7 +89078,7 @@ EXPORT bool _wrap_ShapeFix_Shape_Perform__SWIG_1 (ShapeFix_Shape *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Shape_Perform\n * wrapname: _wrap_ShapeFix_Shape_Perform__SWIG_1\n * fulldecl: Standard_Boolean ShapeFix_Shape::Perform()"; + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixGap3d\n * wrapname: _wrap_ShapeFix_Wire_FixGap3d__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixGap3d(Standard_Integer const,Standard_Boolean const)"; signal_lisp_error(message.c_str()); } } @@ -85394,18 +89090,20 @@ EXPORT bool _wrap_ShapeFix_Shape_Perform__SWIG_1 (ShapeFix_Shape *larg1) { } -EXPORT Handle_ShapeFix_Solid *_wrap_ShapeFix_Shape_FixSolidTool (ShapeFix_Shape *larg1) { - Handle_ShapeFix_Solid * lresult = (Handle_ShapeFix_Solid *)0 ; - ShapeFix_Shape *arg1 = (ShapeFix_Shape *) 0 ; - Handle_ShapeFix_Solid result; +EXPORT bool _wrap_ShapeFix_Wire_FixGap3d__SWIG_1 (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Boolean result; arg1 = larg1; + arg2 = larg2; try { { try { OCC_CATCH_SIGNALS - result = ((ShapeFix_Shape const *)arg1)->FixSolidTool(); + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixGap3d__SWIG_0(arg1,arg2); } catch(Standard_Failure const& error) { @@ -85415,30 +89113,37 @@ EXPORT Handle_ShapeFix_Solid *_wrap_ShapeFix_Shape_FixSolidTool (ShapeFix_Shape if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixSolidTool\n * wrapname: _wrap_ShapeFix_Shape_FixSolidTool\n * fulldecl: Handle_ShapeFix_Solid ShapeFix_Shape::FixSolidTool() const"; + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixGap3d\n * wrapname: _wrap_ShapeFix_Wire_FixGap3d__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixGap3d(Standard_Integer const)"; signal_lisp_error(message.c_str()); } } - lresult = new Handle_ShapeFix_Solid(result); + lresult = (bool)result; return lresult; } catch (...) { - return (Handle_ShapeFix_Solid *)0; + return (bool)0; } } -EXPORT Handle_ShapeFix_Shell *_wrap_ShapeFix_Shape_FixShellTool (ShapeFix_Shape *larg1) { - Handle_ShapeFix_Shell * lresult = (Handle_ShapeFix_Shell *)0 ; - ShapeFix_Shape *arg1 = (ShapeFix_Shape *) 0 ; - Handle_ShapeFix_Shell result; +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixGap2d__SWIG_0(Handle_ShapeFix_Wire *self,Standard_Integer const num,Standard_Boolean const convert=Standard_False){ + return (*self)->FixGap2d(num, convert); + } +EXPORT bool _wrap_ShapeFix_Wire_FixGap2d__SWIG_0 (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2, bool larg3) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Boolean arg3 ; + Standard_Boolean result; arg1 = larg1; + arg2 = larg2; + arg3 = (bool)larg3; try { { try { OCC_CATCH_SIGNALS - result = ((ShapeFix_Shape const *)arg1)->FixShellTool(); + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixGap2d__SWIG_0(arg1,arg2,arg3); } catch(Standard_Failure const& error) { @@ -85448,30 +89153,32 @@ EXPORT Handle_ShapeFix_Shell *_wrap_ShapeFix_Shape_FixShellTool (ShapeFix_Shape if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixShellTool\n * wrapname: _wrap_ShapeFix_Shape_FixShellTool\n * fulldecl: Handle_ShapeFix_Shell ShapeFix_Shape::FixShellTool() const"; + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixGap2d\n * wrapname: _wrap_ShapeFix_Wire_FixGap2d__SWIG_0\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixGap2d(Standard_Integer const,Standard_Boolean const)"; signal_lisp_error(message.c_str()); } } - lresult = new Handle_ShapeFix_Shell(result); + lresult = (bool)result; return lresult; } catch (...) { - return (Handle_ShapeFix_Shell *)0; + return (bool)0; } } -EXPORT Handle_ShapeFix_Face *_wrap_ShapeFix_Shape_FixFaceTool (ShapeFix_Shape *larg1) { - Handle_ShapeFix_Face * lresult = (Handle_ShapeFix_Face *)0 ; - ShapeFix_Shape *arg1 = (ShapeFix_Shape *) 0 ; - Handle_ShapeFix_Face result; +EXPORT bool _wrap_ShapeFix_Wire_FixGap2d__SWIG_1 (Handle_ShapeFix_Wire *larg1, Standard_Integer larg2) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Integer arg2 ; + Standard_Boolean result; arg1 = larg1; + arg2 = larg2; try { { try { OCC_CATCH_SIGNALS - result = ((ShapeFix_Shape const *)arg1)->FixFaceTool(); + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixGap2d__SWIG_0(arg1,arg2); } catch(Standard_Failure const& error) { @@ -85481,22 +89188,25 @@ EXPORT Handle_ShapeFix_Face *_wrap_ShapeFix_Shape_FixFaceTool (ShapeFix_Shape *l if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixFaceTool\n * wrapname: _wrap_ShapeFix_Shape_FixFaceTool\n * fulldecl: Handle_ShapeFix_Face ShapeFix_Shape::FixFaceTool() const"; + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixGap2d\n * wrapname: _wrap_ShapeFix_Wire_FixGap2d__SWIG_1\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixGap2d(Standard_Integer const)"; signal_lisp_error(message.c_str()); } } - lresult = new Handle_ShapeFix_Face(result); + lresult = (bool)result; return lresult; } catch (...) { - return (Handle_ShapeFix_Face *)0; + return (bool)0; } } -EXPORT Handle_ShapeFix_Wire *_wrap_ShapeFix_Shape_FixWireTool (ShapeFix_Shape *larg1) { - Handle_ShapeFix_Wire * lresult = (Handle_ShapeFix_Wire *)0 ; - ShapeFix_Shape *arg1 = (ShapeFix_Shape *) 0 ; - Handle_ShapeFix_Wire result; +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wire_FixTails(Handle_ShapeFix_Wire *self){ + return (*self)->FixTails(); + } +EXPORT bool _wrap_ShapeFix_Wire_FixTails (Handle_ShapeFix_Wire *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wire *arg1 = (Handle_ShapeFix_Wire *) 0 ; + Standard_Boolean result; arg1 = larg1; try { @@ -85504,7 +89214,7 @@ EXPORT Handle_ShapeFix_Wire *_wrap_ShapeFix_Shape_FixWireTool (ShapeFix_Shape *l try { OCC_CATCH_SIGNALS - result = ((ShapeFix_Shape const *)arg1)->FixWireTool(); + result = (Standard_Boolean)Handle_ShapeFix_Wire_FixTails(arg1); } catch(Standard_Failure const& error) { @@ -85514,22 +89224,25 @@ EXPORT Handle_ShapeFix_Wire *_wrap_ShapeFix_Shape_FixWireTool (ShapeFix_Shape *l if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixWireTool\n * wrapname: _wrap_ShapeFix_Shape_FixWireTool\n * fulldecl: Handle_ShapeFix_Wire ShapeFix_Shape::FixWireTool() const"; + message += "\nwrapper details:\n * symname: ShapeFix_Wire_FixTails\n * wrapname: _wrap_ShapeFix_Wire_FixTails\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wire::FixTails()"; signal_lisp_error(message.c_str()); } } - lresult = new Handle_ShapeFix_Wire(result); + lresult = (bool)result; return lresult; } catch (...) { - return (Handle_ShapeFix_Wire *)0; + return (bool)0; } } -EXPORT Handle_ShapeFix_Edge *_wrap_ShapeFix_Shape_FixEdgeTool (ShapeFix_Shape *larg1) { - Handle_ShapeFix_Edge * lresult = (Handle_ShapeFix_Edge *)0 ; - ShapeFix_Shape *arg1 = (ShapeFix_Shape *) 0 ; - Handle_ShapeFix_Edge result; +SWIGINTERN Handle_ShapeFix_Wireframe *new_Handle_ShapeFix_Wireframe(TopoDS_Shape const &shape){ + return new Handle_ShapeFix_Wireframe(new ShapeFix_Wireframe); + } +EXPORT Handle_ShapeFix_Wireframe *_wrap_new_ShapeFix_Wireframe (TopoDS_Shape *larg1) { + Handle_ShapeFix_Wireframe * lresult = (Handle_ShapeFix_Wireframe *)0 ; + TopoDS_Shape *arg1 = 0 ; + Handle_ShapeFix_Wireframe *result = 0 ; arg1 = larg1; try { @@ -85537,7 +89250,7 @@ EXPORT Handle_ShapeFix_Edge *_wrap_ShapeFix_Shape_FixEdgeTool (ShapeFix_Shape *l try { OCC_CATCH_SIGNALS - result = ((ShapeFix_Shape const *)arg1)->FixEdgeTool(); + result = (Handle_ShapeFix_Wireframe *)new_Handle_ShapeFix_Wireframe((TopoDS_Shape const &)*arg1); } catch(Standard_Failure const& error) { @@ -85547,20 +89260,23 @@ EXPORT Handle_ShapeFix_Edge *_wrap_ShapeFix_Shape_FixEdgeTool (ShapeFix_Shape *l if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: ShapeFix_Shape_FixEdgeTool\n * wrapname: _wrap_ShapeFix_Shape_FixEdgeTool\n * fulldecl: Handle_ShapeFix_Edge ShapeFix_Shape::FixEdgeTool() const"; + message += "\nwrapper details:\n * symname: new_ShapeFix_Wireframe\n * wrapname: _wrap_new_ShapeFix_Wireframe\n * fulldecl: Handle_ShapeFix_Wireframe::Handle_ShapeFix_Wireframe(TopoDS_Shape const &)"; signal_lisp_error(message.c_str()); } } - lresult = new Handle_ShapeFix_Edge(result); + lresult = result; return lresult; } catch (...) { - return (Handle_ShapeFix_Edge *)0; + return (Handle_ShapeFix_Wireframe *)0; } } -EXPORT void _wrap_delete_ShapeFix_Shape (ShapeFix_Shape *larg1) { - ShapeFix_Shape *arg1 = (ShapeFix_Shape *) 0 ; +SWIGINTERN void Handle_ShapeFix_Wireframe_Delete(Handle_ShapeFix_Wireframe *self){ + self->~Handle_ShapeFix_Wireframe(); + } +EXPORT void _wrap_ShapeFix_Wireframe_Delete (Handle_ShapeFix_Wireframe *larg1) { + Handle_ShapeFix_Wireframe *arg1 = (Handle_ShapeFix_Wireframe *) 0 ; arg1 = larg1; try { @@ -85568,7 +89284,7 @@ EXPORT void _wrap_delete_ShapeFix_Shape (ShapeFix_Shape *larg1) { try { OCC_CATCH_SIGNALS - delete arg1; + Handle_ShapeFix_Wireframe_Delete(arg1); } catch(Standard_Failure const& error) { @@ -85578,7 +89294,7 @@ EXPORT void _wrap_delete_ShapeFix_Shape (ShapeFix_Shape *larg1) { if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: delete_ShapeFix_Shape\n * wrapname: _wrap_delete_ShapeFix_Shape\n * fulldecl: ShapeFix_Shape::~ShapeFix_Shape()"; + message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_Delete\n * wrapname: _wrap_ShapeFix_Wireframe_Delete\n * fulldecl: void Handle_ShapeFix_Wireframe::Delete()"; signal_lisp_error(message.c_str()); } } @@ -85589,8 +89305,13 @@ EXPORT void _wrap_delete_ShapeFix_Shape (ShapeFix_Shape *larg1) { } -EXPORT void _wrap_delete_Message_ProgressIndicator (Handle_Message_ProgressIndicator *larg1) { - Handle_Message_ProgressIndicator *arg1 = (Handle_Message_ProgressIndicator *) 0 ; +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wireframe_FixWireGaps(Handle_ShapeFix_Wireframe *self){ + return (*self)->FixWireGaps(); + } +EXPORT bool _wrap_ShapeFix_Wireframe_FixWireGaps (Handle_ShapeFix_Wireframe *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wireframe *arg1 = (Handle_ShapeFix_Wireframe *) 0 ; + Standard_Boolean result; arg1 = larg1; try { @@ -85598,7 +89319,7 @@ EXPORT void _wrap_delete_Message_ProgressIndicator (Handle_Message_ProgressIndic try { OCC_CATCH_SIGNALS - delete arg1; + result = (Standard_Boolean)Handle_ShapeFix_Wireframe_FixWireGaps(arg1); } catch(Standard_Failure const& error) { @@ -85608,7 +89329,79 @@ EXPORT void _wrap_delete_Message_ProgressIndicator (Handle_Message_ProgressIndic if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: delete_Message_ProgressIndicator\n * wrapname: _wrap_delete_Message_ProgressIndicator\n * fulldecl: Handle_Message_ProgressIndicator::~Handle_Message_ProgressIndicator()"; + message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_FixWireGaps\n * wrapname: _wrap_ShapeFix_Wireframe_FixWireGaps\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wireframe::FixWireGaps()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN Standard_Boolean Handle_ShapeFix_Wireframe_FixSmallEdges(Handle_ShapeFix_Wireframe *self){ + return (*self)->FixSmallEdges(); + } +EXPORT bool _wrap_ShapeFix_Wireframe_FixSmallEdges (Handle_ShapeFix_Wireframe *larg1) { + bool lresult = (bool)0 ; + Handle_ShapeFix_Wireframe *arg1 = (Handle_ShapeFix_Wireframe *) 0 ; + Standard_Boolean result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Boolean)Handle_ShapeFix_Wireframe_FixSmallEdges(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_FixSmallEdges\n * wrapname: _wrap_ShapeFix_Wireframe_FixSmallEdges\n * fulldecl: Standard_Boolean Handle_ShapeFix_Wireframe::FixSmallEdges()"; + signal_lisp_error(message.c_str()); + } + } + lresult = (bool)result; + return lresult; + } catch (...) { + return (bool)0; + } +} + + +SWIGINTERN void Handle_ShapeFix_Wireframe_SetLimitAngle(Handle_ShapeFix_Wireframe *self,Standard_Real const theLimitAngle){ + (*self)->SetLimitAngle(theLimitAngle); + } +EXPORT void _wrap_ShapeFix_Wireframe_SetLimitAngle (Handle_ShapeFix_Wireframe *larg1, Standard_Real larg2) { + Handle_ShapeFix_Wireframe *arg1 = (Handle_ShapeFix_Wireframe *) 0 ; + Standard_Real arg2 ; + + arg1 = larg1; + arg2 = larg2; + try { + { + try + { + OCC_CATCH_SIGNALS + Handle_ShapeFix_Wireframe_SetLimitAngle(arg1,arg2); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_SetLimitAngle\n * wrapname: _wrap_ShapeFix_Wireframe_SetLimitAngle\n * fulldecl: void Handle_ShapeFix_Wireframe::SetLimitAngle(Standard_Real const)"; signal_lisp_error(message.c_str()); } } @@ -85619,6 +89412,78 @@ EXPORT void _wrap_delete_Message_ProgressIndicator (Handle_Message_ProgressIndic } +SWIGINTERN Standard_Real Handle_ShapeFix_Wireframe_LimitAngle(Handle_ShapeFix_Wireframe *self){ + return (*self)->LimitAngle(); + } +EXPORT Standard_Real _wrap_ShapeFix_Wireframe_LimitAngle (Handle_ShapeFix_Wireframe *larg1) { + Standard_Real lresult = (Standard_Real)0 ; + Handle_ShapeFix_Wireframe *arg1 = (Handle_ShapeFix_Wireframe *) 0 ; + Standard_Real result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (Standard_Real)Handle_ShapeFix_Wireframe_LimitAngle(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_LimitAngle\n * wrapname: _wrap_ShapeFix_Wireframe_LimitAngle\n * fulldecl: Standard_Real Handle_ShapeFix_Wireframe::LimitAngle()"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (Standard_Real)0; + } +} + + +SWIGINTERN TopoDS_Shape Handle_ShapeFix_Wireframe_Shape(Handle_ShapeFix_Wireframe *self){ + return (*self)->Shape(); + } +EXPORT TopoDS_Shape *_wrap_ShapeFix_Wireframe_Shape (Handle_ShapeFix_Wireframe *larg1) { + TopoDS_Shape * lresult = (TopoDS_Shape *)0 ; + Handle_ShapeFix_Wireframe *arg1 = (Handle_ShapeFix_Wireframe *) 0 ; + TopoDS_Shape result; + + arg1 = larg1; + try { + { + try + { + OCC_CATCH_SIGNALS + result = Handle_ShapeFix_Wireframe_Shape(arg1); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: ShapeFix_Wireframe_Shape\n * wrapname: _wrap_ShapeFix_Wireframe_Shape\n * fulldecl: TopoDS_Shape Handle_ShapeFix_Wireframe::Shape()"; + signal_lisp_error(message.c_str()); + } + } + lresult = new TopoDS_Shape(result); + return lresult; + } catch (...) { + return (TopoDS_Shape *)0; + } +} + + #include #include @@ -95584,7 +99449,91 @@ EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_0 () { } -EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_1 (TopoDS_Shape *larg1, Standard_Real larg2, bool larg3, Standard_Real larg4) { +EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_1 (TopoDS_Shape *larg1, Standard_Real larg2, bool larg3, Standard_Real larg4, bool larg5, bool larg6) { + BRepMesh_IncrementalMesh * lresult = (BRepMesh_IncrementalMesh *)0 ; + TopoDS_Shape *arg1 = 0 ; + Standard_Real arg2 ; + Standard_Boolean arg3 ; + Standard_Real arg4 ; + Standard_Boolean arg5 ; + Standard_Boolean arg6 ; + BRepMesh_IncrementalMesh *result = 0 ; + + arg1 = larg1; + arg2 = larg2; + arg3 = (bool)larg3; + arg4 = larg4; + arg5 = (bool)larg5; + arg6 = (bool)larg6; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (BRepMesh_IncrementalMesh *)new BRepMesh_IncrementalMesh((TopoDS_Shape const &)*arg1,arg2,arg3,arg4,arg5,arg6); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: new_BRepMesh_IncrementalMesh\n * wrapname: _wrap_new_BRepMesh_IncrementalMesh__SWIG_1\n * fulldecl: BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(TopoDS_Shape const &,Standard_Real const,Standard_Boolean const,Standard_Real const,Standard_Boolean const,Standard_Boolean const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (BRepMesh_IncrementalMesh *)0; + } +} + + +EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_2 (TopoDS_Shape *larg1, Standard_Real larg2, bool larg3, Standard_Real larg4, bool larg5) { + BRepMesh_IncrementalMesh * lresult = (BRepMesh_IncrementalMesh *)0 ; + TopoDS_Shape *arg1 = 0 ; + Standard_Real arg2 ; + Standard_Boolean arg3 ; + Standard_Real arg4 ; + Standard_Boolean arg5 ; + BRepMesh_IncrementalMesh *result = 0 ; + + arg1 = larg1; + arg2 = larg2; + arg3 = (bool)larg3; + arg4 = larg4; + arg5 = (bool)larg5; + try { + { + try + { + OCC_CATCH_SIGNALS + result = (BRepMesh_IncrementalMesh *)new BRepMesh_IncrementalMesh((TopoDS_Shape const &)*arg1,arg2,arg3,arg4,arg5); + } + catch(Standard_Failure const& error) + { + char *error_name = (char*) error.DynamicType()->Name(); + char *error_message = (char*) error.GetMessageString(); + std::string message; + if (error_name) message += std::string(error_name) + "\n"; + if (error_message) message += std::string(error_message); + // log SWIG specific debug information + message += "\nwrapper details:\n * symname: new_BRepMesh_IncrementalMesh\n * wrapname: _wrap_new_BRepMesh_IncrementalMesh__SWIG_2\n * fulldecl: BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(TopoDS_Shape const &,Standard_Real const,Standard_Boolean const,Standard_Real const,Standard_Boolean const)"; + signal_lisp_error(message.c_str()); + } + } + lresult = result; + return lresult; + } catch (...) { + return (BRepMesh_IncrementalMesh *)0; + } +} + + +EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_3 (TopoDS_Shape *larg1, Standard_Real larg2, bool larg3, Standard_Real larg4) { BRepMesh_IncrementalMesh * lresult = (BRepMesh_IncrementalMesh *)0 ; TopoDS_Shape *arg1 = 0 ; Standard_Real arg2 ; @@ -95611,7 +99560,7 @@ EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_1 (Top if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: new_BRepMesh_IncrementalMesh\n * wrapname: _wrap_new_BRepMesh_IncrementalMesh__SWIG_1\n * fulldecl: BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(TopoDS_Shape const &,Standard_Real const,Standard_Boolean const,Standard_Real const)"; + message += "\nwrapper details:\n * symname: new_BRepMesh_IncrementalMesh\n * wrapname: _wrap_new_BRepMesh_IncrementalMesh__SWIG_3\n * fulldecl: BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(TopoDS_Shape const &,Standard_Real const,Standard_Boolean const,Standard_Real const)"; signal_lisp_error(message.c_str()); } } @@ -95623,7 +99572,7 @@ EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_1 (Top } -EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_2 (TopoDS_Shape *larg1, Standard_Real larg2, bool larg3) { +EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_4 (TopoDS_Shape *larg1, Standard_Real larg2, bool larg3) { BRepMesh_IncrementalMesh * lresult = (BRepMesh_IncrementalMesh *)0 ; TopoDS_Shape *arg1 = 0 ; Standard_Real arg2 ; @@ -95648,7 +99597,7 @@ EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_2 (Top if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: new_BRepMesh_IncrementalMesh\n * wrapname: _wrap_new_BRepMesh_IncrementalMesh__SWIG_2\n * fulldecl: BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(TopoDS_Shape const &,Standard_Real const,Standard_Boolean const)"; + message += "\nwrapper details:\n * symname: new_BRepMesh_IncrementalMesh\n * wrapname: _wrap_new_BRepMesh_IncrementalMesh__SWIG_4\n * fulldecl: BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(TopoDS_Shape const &,Standard_Real const,Standard_Boolean const)"; signal_lisp_error(message.c_str()); } } @@ -95660,7 +99609,7 @@ EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_2 (Top } -EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_3 (TopoDS_Shape *larg1, Standard_Real larg2) { +EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_5 (TopoDS_Shape *larg1, Standard_Real larg2) { BRepMesh_IncrementalMesh * lresult = (BRepMesh_IncrementalMesh *)0 ; TopoDS_Shape *arg1 = 0 ; Standard_Real arg2 ; @@ -95683,7 +99632,7 @@ EXPORT BRepMesh_IncrementalMesh *_wrap_new_BRepMesh_IncrementalMesh__SWIG_3 (Top if (error_name) message += std::string(error_name) + "\n"; if (error_message) message += std::string(error_message); // log SWIG specific debug information - message += "\nwrapper details:\n * symname: new_BRepMesh_IncrementalMesh\n * wrapname: _wrap_new_BRepMesh_IncrementalMesh__SWIG_3\n * fulldecl: BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(TopoDS_Shape const &,Standard_Real const)"; + message += "\nwrapper details:\n * symname: new_BRepMesh_IncrementalMesh\n * wrapname: _wrap_new_BRepMesh_IncrementalMesh__SWIG_5\n * fulldecl: BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(TopoDS_Shape const &,Standard_Real const)"; signal_lisp_error(message.c_str()); } } diff --git a/src/shape-fix/shape-fix-wire.lisp b/src/shape-fix/shape-fix-wire.lisp new file mode 100755 index 00000000..d1421727 --- /dev/null +++ b/src/shape-fix/shape-fix-wire.lisp @@ -0,0 +1,131 @@ +(in-package :oc) + +(defmethod initialize-instance :after ((object shape-fix-wire) &rest initargs + &key wire face prec &allow-other-keys) + (let ((pointer + (cond ((and (typep wire 'topods-wire) + (typep face 'topods-face) + (typep prec 'real)) + (_wrap_new_ShapeFix_Wire__SWIG_1 (ff-pointer wire) (ff-pointer face) (coerce prec 'double-float))) + ((and (null wire) (null face) (null prec)) + (_wrap_new_ShapeFix_Wire__SWIG_0)) + (t (error "Invalid arguments to constructor: ~S" initargs))))) + (setf (ff-pointer object) pointer) ;; + (oc:finalize object) + (values))) + +(defmethod clear-modes ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_ClearModes (ff-pointer object))) + +(defmethod clear-statuses ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_ClearStatuses (ff-pointer object))) + +(defmethod init-shape-fix ((object shape-fix-wire) (wire topods-wire) (face topods-face) (prec real)) + (_wrap_ShapeFix_Wire_Init__SWIG_0 (ff-pointer object) + (ff-pointer wire) + (ff-pointer face) + (coerce prec 'double-float))) + +(defmethod load-shape-fix ((object shape-fix-wire) (wire topods-wire)) + (_wrap_ShapeFix_Wire_Load__SWIG_0 (ff-pointer object) (ff-pointer wire))) + +(defmethod set-max-tail-angle ((object shape-fix-wire) (the-max-tail-angle real)) + (_wrap_ShapeFix_Wire_SetMaxTailAngle (ff-pointer object) (coerce the-max-tail-angle 'double-float))) + +(defmethod set-max-tail-angle ((object shape-fix-wire) (the-max-tail-width real)) + (_wrap_ShapeFix_Wire_SetMaxTailWidth (ff-pointer object) (coerce the-max-tail-width 'double-float))) + +(defmethod number-of-edges ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_NbEdges (ff-pointer object))) + +(defmethod analyzer ((object shape-fix-wire)) + (let ((pointer (_wrap_ShapeFix_Wire_Analyzer (ff-pointer object)))) + ;;(make-instance 'shape-analysis-wire :ff-pointer pointer) + pointer)) + +(defmethod perform ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_Perform (ff-pointer object))) + +(defmethod fix-reorder ((object shape-fix-wire) &key wi) + (if wi + (_wrap_ShapeFix_Wire_FixReorder__SWIG_1 (ff-pointer object) (ff-pointer wi)) + (_wrap_ShapeFix_Wire_FixReorder__SWIG_0 (ff-pointer object)))) + +(defmethod fix-small ((object shape-fix-wire)&rest initargs + &key (precsmall nil precsmall-present-p) + (lockvtx nil lockvtx-present-p) + num) + (cond ((and precsmall-present-p (realp precsmall) lockvtx-present-p (integerp num)) + (_wrap_ShapeFix_Wire_FixSmall__SWIG_2 (ff-pointer object) num + (and lockvtx t) (coerce precsmall 'double-float))) + ((and precsmall-present-p (realp precsmall) lockvtx-present-p) + (_wrap_ShapeFix_Wire_FixSmall__SWIG_0 (ff-pointer object) (and lockvtx t) (coerce precsmall 'double-float))) + (lockvtx-present-p (_wrap_ShapeFix_Wire_FixSmall__SWIG_1 (ff-pointer object) (and lockvtx t))) + (t "Invalid arguments to fix-small: ~S" initargs))) + +(defmethod fix-connected ((object shape-fix-wire) &key (prec nil prec-present-p) num) + (cond ((and prec-present-p (realp prec) (integerp num)) + (_wrap_ShapeFix_Wire_FixConnected__SWIG_2 (ff-pointer object) num (coerce prec 'double-float))) + ((and prec-present-p (realp prec)) + (_wrap_ShapeFix_Wire_FixConnected__SWIG_0 (ff-pointer object) (coerce prec 'double-float))) + (t (_wrap_ShapeFix_Wire_FixConnected__SWIG_1 (ff-pointer object))))) + +(defmethod fix-edge-curves ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_FixEdgeCurves (ff-pointer object))) + +(defmethod fix-degenerated ((object shape-fix-wire) &key (num nil num-present-p)) + (if (and num-present-p (integerp num)) + (_wrap_ShapeFix_Wire_FixDegenerated__SWIG_1 (ff-pointer object) num) + (if (null num-present-p) + (_wrap_ShapeFix_Wire_FixDegenerated__SWIG_0 (ff-pointer object)) + (error "`num' argument not an integer: ~S" num)))) + +(defmethod fix-self-intersection ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_FixSelfIntersection (ff-pointer object))) + +(defmethod fix-lacking ((object shape-fix-wire) &rest initargs &key (force nil force-present-p) num) + (cond ((and force-present-p (integerp num)) + (_wrap_ShapeFix_Wire_FixLacking__SWIG_2 (ff-pointer object) num (and force t))) + (force-present-p (_wrap_ShapeFix_Wire_FixLacking__SWIG_0 (ff-pointer object) (and force t))) + ((and (null force-present-p) (null num)) + (_wrap_ShapeFix_Wire_FixLacking__SWIG_1 (ff-pointer object))) + (t "Invalid arguments to fix-lacking: ~S" initargs))) + +(defmethod fix-closed ((object shape-fix-wire) &key (prec nil prec-present-p)) + (cond ((and prec-present-p (realp prec)) + (_wrap_ShapeFix_Wire_FixClosed__SWIG_0 (ff-pointer object) (coerce prec 'double-float))) + (t (_wrap_ShapeFix_Wire_FixClosed__SWIG_1 (ff-pointer object))))) + +(defmethod fix-gaps-3d ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_FixGaps3d (ff-pointer object))) + +(defmethod fix-gaps-2d ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_FixGaps2d (ff-pointer object))) + +(defmethod fix-seam ((object shape-fix-wire) (num integer)) + (_wrap_ShapeFix_Wire_FixSeam (ff-pointer object) num)) + +(defmethod fix-shifted ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_FixShifted (ff-pointer object))) + +(defmethod fix-notched-edges ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_FixNotchedEdges (ff-pointer object))) + +(defmethod fix-gap-3d ((object shape-fix-wire) (num integer) &key (convert nil convert-present-p)) + (if convert-present-p + (_wrap_ShapeFix_Wire_FixGap3d__SWIG_0 (ff-pointer object) num (and convert t)) + (_wrap_ShapeFix_Wire_FixGap3d__SWIG_1 (ff-pointer object) num))) + +(defmethod fix-gap-2d ((object shape-fix-wire) (num integer) &key (convert nil convert-present-p)) + (if convert-present-p + (_wrap_ShapeFix_Wire_FixGap2d__SWIG_0 (ff-pointer object) num (and convert t)) + (_wrap_ShapeFix_Wire_FixGap2d__SWIG_1 (ff-pointer object) num))) + +(defmethod fix-tails ((object shape-fix-wire)) + (_wrap_ShapeFix_Wire_FixTails (ff-pointer object))) + +(defmethod wire-api-make ((object shape-fix-wire)) + (with-topods-shape (_wrap_ShapeFix_Wire_WireAPIMake (ff-pointer object)))) + +(defmethod wire ((object shape-fix-wire)) + (with-topods-shape (_wrap_ShapeFix_Wire_Wire (ff-pointer object)))) diff --git a/src/shape-fix/shapefix.i b/src/shape-fix/shapefix.i index 86e93178..0eb8aa5a 100755 --- a/src/shape-fix/shapefix.i +++ b/src/shape-fix/shapefix.i @@ -11,74 +11,631 @@ #include #include #include +#include +#include +#include %} +%{ +#include + %} + %rename(Message_ProgressIndicator) Handle_Message_ProgressIndicator; -%rename(ShapeFix_Solid) Handle_ShapeFix_Solid; -%rename(ShapeFix_Shell) Handle_ShapeFix_Shell; -%rename(ShapeFix_Face) Handle_ShapeFix_Face; -%rename(ShapeFix_Wire) Handle_ShapeFix_Wire; +%rename(ShapeExtend_BasicMsgRegistrator) Handle_ShapeExtend_BasicMsgRegistrator; +%rename(ShapeBuild_ReShape) Handle_ShapeBuild_ReShape; + +%nodefaultdtor Handle_Message_ProgressIndicator; +class Handle_Message_ProgressIndicator {}; +%nodefaultdtor Handle_ShapeAnalysis_Surface; +class Handle_ShapeAnalysis_Surface {}; + +%nodefaultdtor ShapeFix; +class ShapeFix +{ + public: + static Standard_Boolean SameParameter (const TopoDS_Shape& shape, const Standard_Boolean enforce); + static Standard_Boolean SameParameter (const TopoDS_Shape& shape, const Standard_Boolean enforce, const Standard_Real preci); + static Standard_Boolean SameParameter (const TopoDS_Shape& shape, const Standard_Boolean enforce, const Standard_Real preci, const Handle_Message_ProgressIndicator& theProgress); + static Standard_Boolean SameParameter (const TopoDS_Shape& shape, const Standard_Boolean enforce, const Standard_Real preci, const Handle_Message_ProgressIndicator& theProgress, const Handle_ShapeExtend_BasicMsgRegistrator& theMsgReg); + + static void EncodeRegularity (const TopoDS_Shape& shape, const Standard_Real tolang = 1.0e-10); + + static TopoDS_Shape RemoveSmallEdges (TopoDS_Shape& shape, const Standard_Real Tolerance, Handle_ShapeBuild_ReShape& context); + + static Standard_Boolean FixVertexPosition (TopoDS_Shape& theshape, const Standard_Real theTolerance, const Handle_ShapeBuild_ReShape& thecontext); + + static Standard_Real LeastEdgeSize (TopoDS_Shape& theshape); +}; + +%rename(ShapeFix_Root) Handle_ShapeFix_Root; +%rename(ShapeFix_EdgeProjAux) Handle_ShapeFix_EdgeProjAux; %rename(ShapeFix_Edge) Handle_ShapeFix_Edge; +%rename(ShapeFix_Wire) Handle_ShapeFix_Wire; +%rename(ShapeFix_Face) Handle_ShapeFix_Face; +%rename(ShapeFix_FixSmallFace) Handle_ShapeFix_FixSmallFace; +%rename(ShapeFix_FixSmallSolid) Handle_ShapeFix_FixSmallSolid; +%rename(ShapeFix_WireVertex) Handle_ShapeFix_WireVertex; +%rename(ShapeFix_Wireframe) Handle_ShapeFix_Wireframe; +%rename(ShapeFix_FreeBounds) Handle_ShapeFix_FreeBounds; +%rename(ShapeFix_FaceConnect) Handle_ShapeFix_FaceConnect; +%rename(ShapeFix_Shell) Handle_ShapeFix_Shell; +%rename(ShapeFix_Solid) Handle_ShapeFix_Solid; +%rename(ShapeFix_ShapeTolerance) Handle_ShapeFix_ShapeTolerance; +%rename(ShapeFix_Shape) Handle_ShapeFix_Shape; +%rename(ShapeFix_EdgeConnect) Handle_ShapeFix_EdgeConnect; +%rename(ShapeFix_ComposeShell) Handle_ShapeFix_ComposeShell; +%rename(ShapeFix_SplitCommonVertex) Handle_ShapeFix_SplitCommonVertex; +%rename(ShapeFix_WireSegment) Handle_ShapeFix_WireSegment; +%rename(ShapeFix_IntersectionTool) Handle_ShapeFix_IntersectionTool; +%rename(ShapeFix_SplitTool) Handle_ShapeFix_SplitTool; -class ShapeFix_Root +%nodefaultdtor Handle_ShapeFix_Root; +class Handle_ShapeFix_Root : public Handle_MMgt_TShared { - ShapeFix_Root()=0; - public: - void SetPrecision(const Standard_Real preci) ; - Standard_Real Precision() const; - void SetContext(const ShapeBuild_ReShape * context) ; + Handle_ShapeFix_Root()=0; }; -%extend ShapeFix_Root +%extend Handle_ShapeFix_Root { - Handle_ShapeBuild_ReShape getContext() - { - Handle_ShapeBuild_ReShape p = self->Context(); - return p; - } + void Set (const Handle_ShapeFix_Root& Root) { + (*self)->Set(Root); + } + void SetContext (const Handle_ShapeBuild_ReShape& context) { + (*self)->SetContext(context); + } + Handle_ShapeBuild_ReShape Context() { + return (*self)->Context(); + } + void SetMsgRegistrator (const Handle_ShapeExtend_BasicMsgRegistrator& msgreg) { + (*self)->SetMsgRegistrator(msgreg); + } + Handle_ShapeExtend_BasicMsgRegistrator MsgRegistrator() { + return (*self)->MsgRegistrator(); + } + void SetPrecision (const Standard_Real preci) { + (*self)->SetPrecision(preci); + } + Standard_Real Precision() { + return (*self)->Precision(); + } + void SetMinTolerance (const Standard_Real mintol) { + (*self)->SetMinTolerance(mintol); + } + Standard_Real MaxTolerance() { + return (*self)->MaxTolerance(); + } + Standard_Real LimitTolerance (const Standard_Real toler) { + return (*self)->LimitTolerance(toler); + } + void SendMsg (const TopoDS_Shape& shape, const Message_Msg& message, const Message_Gravity gravity = Message_Info) { + (*self)->SendMsg(shape, message, gravity); + } + void SendMsg (const Message_Msg& message, const Message_Gravity gravity = Message_Info) { + (*self)->SendMsg(message, gravity); + } + void SendWarning (const TopoDS_Shape& shape, const Message_Msg& message) { + (*self)->SendWarning(shape, message); + } + void SendWarning (const Message_Msg& message) { + (*self)->SendWarning(message); + } + void SendFail (const TopoDS_Shape& shape, const Message_Msg& message) { + (*self)->SendFail(shape, message); + } + void SendFail (const Message_Msg& message) { + (*self)->SendFail(message); + } } -class ShapeFix_Wireframe: public ShapeFix_Root +%nodefaultdtor Handle_ShapeFix_Shape; +class Handle_ShapeFix_Shape : public Handle_ShapeFix_Root +{ +}; +%extend Handle_ShapeFix_Shape { + Handle_ShapeFix_Shape() { + return new Handle_ShapeFix_Shape(new ShapeFix_Shape()); + } + Handle_ShapeFix_Shape(const TopoDS_Shape& shape) { + return new Handle_ShapeFix_Shape(new ShapeFix_Shape(shape)); + } + void Init(const TopoDS_Shape& shape) { + (*self)->Init(shape); + } + Standard_Boolean Perform () { + return (*self)->Perform(); + } + Standard_Boolean Perform (const Handle_Message_ProgressIndicator& theProgress) { + return (*self)->Perform(theProgress); + } + TopoDS_Shape Shape() { + return (*self)->Shape(); + } + Handle_ShapeFix_Solid FixSolidTool() { + return (*self)->FixSolidTool(); + } + Handle_ShapeFix_Shell FixShellTool() { + return (*self)->FixShellTool(); + } + Handle_ShapeFix_Face FixFaceTool() { + return (*self)->FixFaceTool(); + } + Handle_ShapeFix_Wire FixWireTool() { + return (*self)->FixWireTool(); + } + Handle_ShapeFix_Edge FixEdgeTool() { + return (*self)->FixEdgeTool(); + } + Standard_Boolean Status (const ShapeExtend_Status status) { + return (*self)->Status(status); + } +} +%nodefaultdtor Handle_ShapeFix_EdgeProjAux; +class Handle_ShapeFix_EdgeProjAux : public Handle_MMgt_TShared +{ + /* Handle_ShapeFix_EdgeProjAux()=0; */ +}; +%extend Handle_ShapeFix_EdgeProjAux +{ + Handle_ShapeFix_EdgeProjAux() { + return new Handle_ShapeFix_EdgeProjAux(new ShapeFix_EdgeProjAux()); + } + Handle_ShapeFix_EdgeProjAux(const TopoDS_Face& F, const TopoDS_Edge& E) { + return new Handle_ShapeFix_EdgeProjAux(new ShapeFix_EdgeProjAux(F, E)); + } + void Delete() { + self->~Handle_ShapeFix_EdgeProjAux(); + } + void Init (const TopoDS_Face& F, const TopoDS_Edge& E) { + (*self)->Init(F, E); + } + void Compute (const Standard_Real preci) { + (*self)->Compute(preci); + } + Standard_Boolean IsFirstDone() { + return (*self)->IsFirstDone(); + } + Standard_Boolean IsLastDone() { + return (*self)->IsLastDone(); + } + Standard_Real FirstParam() { + return (*self)->FirstParam(); + } + Standard_Real LastParam() { + return (*self)->LastParam(); + } + Standard_Boolean IsIso (const Handle_Geom2d_Curve& C) { + return (*self)->IsIso(C); + } +} +%nodefaultdtor Handle_ShapeConstruct_ProjectCurveOnSurface; +class Handle_ShapeConstruct_ProjectCurveOnSurface {}; - public: - ShapeFix_Wireframe(const TopoDS_Shape& shape); +%nodefaultdtor Handle_ShapeFix_Edge; +class Handle_ShapeFix_Edge : public Handle_MMgt_TShared +{ + /* Handle_ShapeFix_Edge()=0; */ +}; +%extend Handle_ShapeFix_Edge { + Handle_ShapeFix_Edge() { + return new Handle_ShapeFix_Edge(new ShapeFix_Edge()); + } + void Delete() { + self->~Handle_ShapeFix_Edge(); + } + Handle_ShapeConstruct_ProjectCurveOnSurface Projector() { + return (*self)->Projector(); + } + Standard_Boolean FixRemovePCurve (const TopoDS_Edge& edge, const TopoDS_Face& face) { + return (*self)->FixRemovePCurve(edge, face); + } + Standard_Boolean FixRemovePCurve (const TopoDS_Edge& edge, const Handle_Geom_Surface& surface, const TopLoc_Location& location) { + return (*self)->FixRemovePCurve(edge, surface, location); + } + Standard_Boolean FixRemoveCurve3d (const TopoDS_Edge& edge) { + return (*self)->FixRemoveCurve3d(edge); + } + Standard_Boolean FixAddPCurve (const TopoDS_Edge& edge, const TopoDS_Face& face, const Standard_Boolean isSeam, const Standard_Real prec = 0.0) { + return (*self)->FixAddPCurve(edge, face, isSeam, prec); + } + Standard_Boolean FixAddPCurve (const TopoDS_Edge& edge, const Handle_Geom_Surface& surface, const TopLoc_Location& location, const Standard_Boolean isSeam, const Standard_Real prec = 0.0) { + return (*self)->FixAddPCurve(edge, surface, location, isSeam, prec); + } + Standard_Boolean FixAddPCurve (const TopoDS_Edge& edge, const TopoDS_Face& face, const Standard_Boolean isSeam, const Handle_ShapeAnalysis_Surface& surfana, const Standard_Real prec = 0.0) { + return (*self)->FixAddPCurve(edge, face, isSeam, surfana, prec); + } + Standard_Boolean FixAddPCurve (const TopoDS_Edge& edge, const Handle_Geom_Surface& surface, const TopLoc_Location& location, const Standard_Boolean isSeam, const Handle_ShapeAnalysis_Surface& surfana, const Standard_Real prec = 0.0) { + return (*self)->FixAddPCurve(edge, surface, location, isSeam, surfana, prec); + } + Standard_Boolean FixAddCurve3d (const TopoDS_Edge& edge) { + return (*self)->FixAddCurve3d(edge); + } + Standard_Boolean FixVertexTolerance (const TopoDS_Edge& edge, const TopoDS_Face& face) { + return (*self)->FixVertexTolerance(edge, face); + } + Standard_Boolean FixVertexTolerance (const TopoDS_Edge& edge) { + return (*self)->FixVertexTolerance(edge); + } + Standard_Boolean FixReversed2d (const TopoDS_Edge& edge, const TopoDS_Face& face) { + return (*self)->FixReversed2d(edge, face); + } + Standard_Boolean FixReversed2d (const TopoDS_Edge& edge, const Handle_Geom_Surface& surface, const TopLoc_Location& location) { + return (*self)->FixReversed2d(edge, surface, location); + } + Standard_Boolean FixSameParameter (const TopoDS_Edge& edge, const Standard_Real tolerance = 0.0) { + return (*self)->FixSameParameter(edge, tolerance); + } + Standard_Boolean FixSameParameter (const TopoDS_Edge& edge, const TopoDS_Face& face, const Standard_Real tolerance = 0.0) { + return (*self)->FixSameParameter(edge, face, tolerance); + } + Standard_Boolean Status (const ShapeExtend_Status status) { + return (*self)->Status(status); + } + void SetContext (const Handle_ShapeBuild_ReShape& context) { + (*self)->SetContext(context); + } + Handle_ShapeBuild_ReShape Context() { + return (*self)->Context(); + } +} +%nodefaultdtor Handle_ShapeFix_Wire; +class Handle_ShapeFix_Wire : public Handle_ShapeFix_Root +{ +}; +%extend Handle_ShapeFix_Wire { + Handle_ShapeFix_Wire() { + return new Handle_ShapeFix_Wire(new ShapeFix_Wire()); + } + Handle_ShapeFix_Wire(const TopoDS_Wire& wire, const TopoDS_Face& face, const Standard_Real prec) { + return new Handle_ShapeFix_Wire(new ShapeFix_Wire(wire, face, prec)); + } + void Delete() { + self->~Handle_ShapeFix_Wire(); + } + void ClearModes() { + (*self)->ClearModes(); + } + void ClearStatuses() { + (*self)->ClearStatuses(); + } + void Init (const TopoDS_Wire& wire, const TopoDS_Face& face, const Standard_Real prec) { + (*self)->Init(wire, face, prec); + } + void Init (const Handle_ShapeAnalysis_Wire& saw) { + (*self)->Init(saw); + } + void Load (const TopoDS_Wire& wire) { + (*self)->Load(wire); + } + void Load (const Handle_ShapeExtend_WireData& sbwd) { + (*self)->Load(sbwd); + } + /* + void SetFace (const TopoDS_Face& face) { + (*self)->SetFace(face); + } + void SetSurface (const Handle_Geom_Surface& surf) { + (*self)->SetSurface(surf); + } + void SetSurface (const Handle_Geom_Surface& surf, const TopLoc_Location& loc) { + (*self)->SetSurface(surf, loc); + } + */ + void SetMaxTailAngle (const Standard_Real theMaxTailAngle) { + (*self)->SetMaxTailAngle(theMaxTailAngle); + } + void SetMaxTailWidth (const Standard_Real theMaxTailWidth) { + (*self)->SetMaxTailWidth(theMaxTailWidth); + } + /* + Standard_Boolean IsLoaded() { + return (*self)->IsLoaded(); + } + Standard_Boolean IsReady() { + return (*self)->IsReady(); + } +*/ + Standard_Integer NbEdges() { + return (*self)->NbEdges(); + } - Standard_Boolean FixWireGaps(); + TopoDS_Wire Wire() { + return (*self)->Wire(); + } + TopoDS_Wire WireAPIMake() { + return (*self)->WireAPIMake(); + } - Standard_Boolean FixSmallEdges() ; + Handle_ShapeAnalysis_Wire Analyzer() { + return (*self)->Analyzer(); + } + /* + Handle_ShapeExtend_WireData& WireData() { + return (*self)->WireData(); + } + TopoDS_Face& Face() { + return (*self)->Face(); + } + Standard_Boolean GetTopologyMode() { + return *((*self)->ModifyTopologyMode()); + } + void SetTopologyMode(Standard_Boolean mode) { + *((*self)->ModifyTopologyMode()) = mode; + } + Standard_Boolean GetGeometryMode() { + return *((*self)->ModifyGeometryMode()); + } + void SetGeometryMode(Standard_Boolean mode) { + *((*self)->ModifyGeometryMode()) = mode; + } + Standard_Integer GetRemoveLoopMode() { + return *((*self)->ModifyRemoveLoopMode()); + } + void SetRemoveLoopMode(Standard_Integer mode) { + *((*self)->ModifyRemoveLoopMode()) = mode; + } + Standard_Boolean GetClosedWireMode() { + return *((*self)->ClosedWireMode()); + } + void SetClosedWireMode(Standard_Boolean mode) { + *((*self)->ClosedWireMode()) = mode; + } + Standard_Boolean GetPreferencePCurveMode() { + return *((*self)->PreferencePCurveMode()); + } + void SetPreferencePCurveMode(Standard_Boolean mode) { + *((*self)->PreferencePCurveMode()) = mode; + } + Standard_Boolean GetFixGapsByRangesMode() { + return *((*self)->FixGapsByRangesMode()); + } + void SetFixGapsByRangesMode(Standard_Boolean mode) { + *((*self)->FixGapsByRangesMode()) = mode; + } + Standard_Integer GetFixReorderMode() { + return *((*self)->FixReorderMode()); + } + void SetFixReorderMode(Standard_Integer mode) { + *((*self)->FixReorderMode()) = mode; + } + Standard_Integer GetFixSmallMode() { + return *((*self)->FixSmallMode()); + } + void SetFixSmallMode(Standard_Integer mode) { + *((*self)->FixSmallMode()) = mode; + } + Standard_Integer GetFixConnectedMode() { + return *((*self)->FixConnectedMode()); + } + void SetFixConnectedMode(Standard_Integer mode) { + *((*self)->FixConnectedMode()) = mode; + } + Standard_Integer GetFixEdgeCurvesMode() { + return *((*self)->FixEdgeCurvesMode()); + } + void SetFixEdgeCurvesMode(Standard_Integer mode) { + *((*self)->FixEdgeCurvesMode()) = mode; + } + Standard_Integer GetFixDegeneratedMode() { + return *((*self)->FixDegeneratedMode()); + } + void SetFixDegeneratedMode(Standard_Integer mode) { + *((*self)->FixDegeneratedMode()) = mode; + } + Standard_Integer GetFixSelfIntersectionMode() { + return *((*self)->FixSelfIntersectionMode()); + } + void SetFixSelfIntersectionMode(Standard_Integer mode) { + *((*self)->FixSelfIntersectionMode()) = mode; + } + Standard_Integer GetFixLackingMode() { + return *((*self)->FixLackingMode()); + } + void SetFixLackingMode(Standard_Integer mode) { + *((*self)->FixLackingMode()) = mode; + } + Standard_Integer GetFixGaps3dMode() { + return *((*self)->FixGaps3dMode()); + } + void SetFixGaps3dMode(Standard_Integer mode) { + *((*self)->FixGaps3dMode()) = mode; + } + Standard_Integer GetFixGaps2dMode() { + return *((*self)->FixGaps2dMode()); + } + void SetFixGaps2dMode(Standard_Integer mode) { + *((*self)->FixGaps2dMode()) = mode; + } + Standard_Integer GetFixReversed2dMode() { + return *((*self)->FixReversed2dMode()); + } + void SetFixReversed2dMode(Standard_Integer mode) { + *((*self)->FixReversed2dMode()) = mode; + } + Standard_Integer GetFixRemovePCurveMode() { + return *((*self)->FixRemovePCurveMode()); + } + void SetFixRemovePCurveMode(Standard_Integer mode) { + *((*self)->FixRemovePCurveMode()) = mode; + } + Standard_Integer GetFixAddPCurveMode() { + return *((*self)->FixAddPCurveMode()); + } + void SetFixAddPCurveMode(Standard_Integer mode) { + *((*self)->FixAddPCurveMode()) = mode; + } + Standard_Integer GetFixRemoveCurve3dMode() { + return *((*self)->FixRemoveCurve3dMode()); + } + void SetFixRemoveCurve3dMode(Standard_Integer mode) { + *((*self)->FixRemoveCurve3dMode()) = mode; + } + Standard_Integer GetFixAddCurve3dMode() { + return *((*self)->FixAddCurve3dMode()); + } + void SetFixAddCurve3dMode(Standard_Integer mode) { + *((*self)->FixAddCurve3dMode()) = mode; + } + Standard_Integer GetFixSeamMode() { + return *((*self)->FixSeamMode()); + } + void SetFixSeamMode(Standard_Integer mode) { + *((*self)->FixSeamMode()) = mode; + } + Standard_Integer GetFixShiftedMode() { + return *((*self)->FixShiftedMode()); + } + void SetFixShiftedMode(Standard_Integer mode) { + *((*self)->FixShiftedMode()) = mode; + } + Standard_Integer GetFixSameParameterMode() { + return *((*self)->FixSameParameterMode()); + } + void SetFixSameParameterMode(Standard_Integer mode) { + *((*self)->FixSameParameterMode()) = mode; + } + Standard_Integer GetFixVertexToleranceMode() { + return *((*self)->FixVertexToleranceMode()); + } + void SetFixVertexToleranceMode(Standard_Integer mode) { + *((*self)->FixVertexToleranceMode()) = mode; + } + Standard_Integer GetFixNotchedEdgesMode() { + return *((*self)->FixNotchedEdgesMode()); + } + void SetFixNotchedEdgesMode(Standard_Integer mode) { + *((*self)->FixNotchedEdgesMode()) = mode; + } + Standard_Integer GetFixSelfIntersectingEdgeMode() { + return *((*self)->FixSelfIntersectingEdgeMode()); + } + void SetFixSelfIntersectingEdgeMode(Standard_Integer mode) { + *((*self)->FixSelfIntersectingEdgeMode()) = mode; + } + Standard_Integer GetFixIntersectingEdgesMode() { + return *((*self)->FixIntersectingEdgesMode()); + } + void SetFixIntersectingEdgesMode(Standard_Integer mode) { + *((*self)->FixIntersectingEdgesMode()) = mode; + } + Standard_Integer GetFixNonAdjacentIntersectingEdgesMode() { + return *((*self)->FixNonAdjacentIntersectingEdgesMode()); + } + void SetFixNonAdjacentIntersectingEdgesMode(Standard_Integer mode) { + *((*self)->FixNonAdjacentIntersectingEdgesMode()) = mode; + } + Standard_Integer GetFixTailMode() { + return *((*self)->FixTailMode()); + } + void SetFixTailMode(Standard_Integer mode) { + *((*self)->FixTailMode()) = mode; + } + */ + Standard_Boolean Perform() { + return (*self)->Perform(); + } + Standard_Boolean FixReorder() { + return (*self)->FixReorder(); + } + Standard_Integer FixSmall (const Standard_Boolean lockvtx, const Standard_Real precsmall = 0.0) { + return (*self)->FixSmall(lockvtx, precsmall); + } + Standard_Boolean FixConnected (const Standard_Real prec = -1.0) { + return (*self)->FixConnected(prec); + } + Standard_Boolean FixEdgeCurves() { + return (*self)->FixEdgeCurves(); + } + Standard_Boolean FixDegenerated() { + return (*self)->FixDegenerated(); + } + Standard_Boolean FixSelfIntersection() { + return (*self)->FixSelfIntersection(); + } + Standard_Boolean FixLacking (const Standard_Boolean force = Standard_False) { + return (*self)->FixLacking(force); + } + Standard_Boolean FixClosed (const Standard_Real prec = -1.0) { + return (*self)->FixClosed(prec); + } + Standard_Boolean FixGaps3d() { + return (*self)->FixGaps3d(); + } + Standard_Boolean FixGaps2d() { + return (*self)->FixGaps2d(); + } + Standard_Boolean FixReorder (const ShapeAnalysis_WireOrder& wi) { + return (*self)->FixReorder(wi); + } + Standard_Boolean FixSmall (const Standard_Integer num, const Standard_Boolean lockvtx, const Standard_Real precsmall) { + return (*self)->FixSmall(num, lockvtx, precsmall); + } + Standard_Boolean FixConnected (const Standard_Integer num, const Standard_Real prec) { + return (*self)->FixConnected(num, prec); + } + Standard_Boolean FixSeam (const Standard_Integer num) { + return (*self)->FixSeam(num); + } + Standard_Boolean FixShifted() { + return (*self)->FixShifted(); + } + Standard_Boolean FixDegenerated (const Standard_Integer num) { + return (*self)->FixDegenerated(num); + } + Standard_Boolean FixLacking (const Standard_Integer num, const Standard_Boolean force = Standard_False) { + return (*self)->FixLacking(num, force); + } + Standard_Boolean FixNotchedEdges() { + return (*self)->FixNotchedEdges(); + } + Standard_Boolean FixGap3d (const Standard_Integer num, const Standard_Boolean convert = Standard_False) { + return (*self)->FixGap3d(num, convert); + } + Standard_Boolean FixGap2d (const Standard_Integer num, const Standard_Boolean convert = Standard_False) { + return (*self)->FixGap2d(num, convert); + } + Standard_Boolean FixTails() { + return (*self)->FixTails(); + } +} - void SetLimitAngle(const Standard_Real theLimitAngle) ; - Standard_Real LimitAngle() const; - TopoDS_Shape Shape() ; -}; +%nodefaultdtor Handle_ShapeFix_Wireframe; +class Handle_ShapeFix_Wireframe: public Handle_ShapeFix_Root {}; -%extend ShapeFix_Wireframe +%extend Handle_ShapeFix_Wireframe { - void setDropSmallEdges(bool b) - { - self->ModeDropSmallEdges()=b; - } - bool getDropSmallEdges() - { - return self->ModeDropSmallEdges()!=0; - } -}; + Handle_ShapeFix_Wireframe(const TopoDS_Shape& shape) { + return new Handle_ShapeFix_Wireframe(new ShapeFix_Wireframe); + } + void Delete() { + self->~Handle_ShapeFix_Wireframe(); + } + Standard_Boolean FixWireGaps() { + return (*self)->FixWireGaps(); + } + Standard_Boolean FixSmallEdges() { + return (*self)->FixSmallEdges(); + } + void SetLimitAngle(const Standard_Real theLimitAngle) { + (*self)->SetLimitAngle(theLimitAngle); + } + Standard_Real LimitAngle() { + return (*self)->LimitAngle(); + } + TopoDS_Shape Shape() { + return (*self)->Shape(); + } + /* + void SetDropSmallEdges(Standard_Boolean b) + { + self->ModeDropSmallEdges()=b; + } + Standard_Boolean GetDropSmallEdges() + { + return (*self)->ModeDropSmallEdges()!=0; + } + */ +} -class ShapeFix_Shape -{ - public: - ShapeFix_Shape(const TopoDS_Shape& shape)=0; - - TopoDS_Shape Shape() const ; - Standard_Boolean Perform (const Handle_Message_ProgressIndicator& theProgress=0) ; - Handle_ShapeFix_Solid FixSolidTool() const ; - Handle_ShapeFix_Shell FixShellTool() const ; - Handle_ShapeFix_Face FixFaceTool() const ; - Handle_ShapeFix_Wire FixWireTool() const ; - Handle_ShapeFix_Edge FixEdgeTool() const ; -}; -class Handle_Message_ProgressIndicator { -}; diff --git a/src/topods/topods-shape.lisp b/src/topods/topods-shape.lisp index 95258945..5664ab7d 100755 --- a/src/topods/topods-shape.lisp +++ b/src/topods/topods-shape.lisp @@ -13,3 +13,9 @@ (tolerance (_wrap_BRepLib_BuildCurves3d__SWIG_3 (ff-pointer s) tolerance)) (t (_wrap_BRepLib_BuildCurves3d__SWIG_4 (ff-pointer s))))) + +(defmethod closed ((self topods-shape)) + (_wrap_TopoDS_Shape_Closed__SWIG_0 (ff-pointer self))) + +(defmethod (setf closed) (value (self topods-shape)) + (_wrap_TopoDS_Shape_Closed__SWIG_1 (ff-pointer self) (and value t)))