1 # -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 # Author : Paul RASCLE, EDF
29 ## @defgroup l1_geompy_auxiliary Auxiliary data structures and methods
31 ## @defgroup l1_geompy_purpose All package methods, grouped by their purpose
33 ## @defgroup l2_import_export Importing/exporting geometrical objects
34 ## @defgroup l2_creating Creating geometrical objects
36 ## @defgroup l3_basic_go Creating Basic Geometric Objects
38 ## @defgroup l4_curves Creating Curves
41 ## @defgroup l3_3d_primitives Creating 3D Primitives
42 ## @defgroup l3_complex Creating Complex Objects
43 ## @defgroup l3_groups Working with groups
44 ## @defgroup l3_blocks Building by blocks
46 ## @defgroup l4_blocks_measure Check and Improve
49 ## @defgroup l3_sketcher Sketcher
50 ## @defgroup l3_advanced Creating Advanced Geometrical Objects
52 ## @defgroup l4_decompose Decompose objects
53 ## @defgroup l4_decompose_d Decompose objects deprecated methods
54 ## @defgroup l4_access Access to sub-shapes by their unique IDs inside the main shape
55 ## @defgroup l4_obtain Access to sub-shapes by a criteria
56 ## @defgroup l4_advanced Advanced objects creation functions
61 ## @defgroup l2_transforming Transforming geometrical objects
63 ## @defgroup l3_basic_op Basic Operations
64 ## @defgroup l3_boolean Boolean Operations
65 ## @defgroup l3_transform Transformation Operations
66 ## @defgroup l3_local Local Operations (Fillet, Chamfer and other Features)
67 ## @defgroup l3_blocks_op Blocks Operations
68 ## @defgroup l3_healing Repairing Operations
69 ## @defgroup l3_restore_ss Restore presentation parameters and a tree of sub-shapes
72 ## @defgroup l2_measure Using measurement tools
80 from salome_notebook import *
86 ## Enumeration ShapeType as a dictionary. \n
87 ## Topological types of shapes (like Open Cascade types). See GEOM::shape_type for details.
88 # @ingroup l1_geompy_auxiliary
89 ShapeType = {"AUTO":-1, "COMPOUND":0, "COMPSOLID":1, "SOLID":2, "SHELL":3, "FACE":4, "WIRE":5, "EDGE":6, "VERTEX":7, "SHAPE":8}
91 ## Raise an Error, containing the Method_name, if Operation is Failed
92 ## @ingroup l1_geompy_auxiliary
93 def RaiseIfFailed (Method_name, Operation):
94 if Operation.IsDone() == 0 and Operation.GetErrorCode() != "NOT_FOUND_ANY":
95 raise RuntimeError, Method_name + " : " + Operation.GetErrorCode()
97 ## Return list of variables value from salome notebook
98 ## @ingroup l1_geompy_auxiliary
99 def ParseParameters(*parameters):
102 for parameter in parameters:
103 if isinstance(parameter, list):
104 lResults = ParseParameters(*parameter)
105 if len(lResults) > 0:
106 Result.append(lResults[:-1])
107 StringResult += lResults[-1].split(":")
111 if isinstance(parameter,str):
112 if notebook.isVariable(parameter):
113 Result.append(notebook.get(parameter))
115 raise RuntimeError, "Variable with name '" + parameter + "' doesn't exist!!!"
118 Result.append(parameter)
120 StringResult.append(str(parameter))
124 Result.append(":".join(StringResult))
126 Result = ":".join(StringResult)
129 ## Return list of variables value from salome notebook
130 ## @ingroup l1_geompy_auxiliary
134 for parameter in list:
135 if isinstance(parameter,str) and notebook.isVariable(parameter):
136 Result.append(str(notebook.get(parameter)))
139 Result.append(str(parameter))
142 StringResult = StringResult + str(parameter)
143 StringResult = StringResult + ":"
145 StringResult = StringResult[:len(StringResult)-1]
146 return Result, StringResult
148 ## Return list of variables value from salome notebook
149 ## @ingroup l1_geompy_auxiliary
150 def ParseSketcherCommand(command):
153 sections = command.split(":")
154 for section in sections:
155 parameters = section.split(" ")
157 for parameter in parameters:
158 if paramIndex > 1 and parameter.find("'") != -1:
159 parameter = parameter.replace("'","")
160 if notebook.isVariable(parameter):
161 Result = Result + str(notebook.get(parameter)) + " "
164 raise RuntimeError, "Variable with name '" + parameter + "' doesn't exist!!!"
168 Result = Result + str(parameter) + " "
171 StringResult = StringResult + parameter
172 StringResult = StringResult + ":"
174 paramIndex = paramIndex + 1
176 Result = Result[:len(Result)-1] + ":"
178 Result = Result[:len(Result)-1]
179 return Result, StringResult
181 ## Helper function which can be used to pack the passed string to the byte data.
182 ## Only '1' an '0' symbols are valid for the string. The missing bits are replaced by zeroes.
183 ## If the string contains invalid symbol (neither '1' nor '0'), the function raises an exception.
186 ## val = PackData("10001110") # val = 0xAE
187 ## val = PackData("1") # val = 0x80
189 ## @param data unpacked data - a string containing '1' and '0' symbols
190 ## @return data packed to the byte stream
191 ## @ingroup l1_geompy_auxiliary
194 Helper function which can be used to pack the passed string to the byte data.
195 Only '1' an '0' symbols are valid for the string. The missing bits are replaced by zeroes.
196 If the string contains invalid symbol (neither '1' nor '0'), the function raises an exception.
199 data unpacked data - a string containing '1' and '0' symbols
202 data packed to the byte stream
205 val = PackData("10001110") # val = 0xAE
206 val = PackData("1") # val = 0x80
209 if len(data)%8: bytes += 1
211 for b in range(bytes):
212 d = data[b*8:(b+1)*8]
217 if d[i] == "1": val += 1
219 raise "Invalid symbol %s" % d[i]
226 ## Read bitmap texture from the text file.
227 ## In that file, any non-zero symbol represents '1' opaque pixel of the bitmap.
228 ## A zero symbol ('0') represents transparent pixel of the texture bitmap.
229 ## The function returns width and height of the pixmap in pixels and byte stream representing
230 ## texture bitmap itself.
232 ## This function can be used to read the texture to the byte stream in order to pass it to
233 ## the AddTexture() function of geompy class.
237 ## geompy.init_geom(salome.myStudy)
238 ## texture = geompy.readtexture('mytexture.dat')
239 ## texture = geompy.AddTexture(*texture)
240 ## obj.SetMarkerTexture(texture)
242 ## @param fname texture file name
243 ## @return sequence of tree values: texture's width, height in pixels and its byte stream
244 ## @ingroup l1_geompy_auxiliary
245 def ReadTexture(fname):
247 Read bitmap texture from the text file.
248 In that file, any non-zero symbol represents '1' opaque pixel of the bitmap.
249 A zero symbol ('0') represents transparent pixel of the texture bitmap.
250 The function returns width and height of the pixmap in pixels and byte stream representing
251 texture bitmap itself.
252 This function can be used to read the texture to the byte stream in order to pass it to
253 the AddTexture() function of geompy class.
256 fname texture file name
259 sequence of tree values: texture's width, height in pixels and its byte stream
263 geompy.init_geom(salome.myStudy)
264 texture = geompy.readtexture('mytexture.dat')
265 texture = geompy.AddTexture(*texture)
266 obj.SetMarkerTexture(texture)
270 lines = [ l.strip() for l in f.readlines()]
273 if lines: maxlen = max([len(x) for x in lines])
275 if maxlen%8: lenbytes += 1
279 lenline = (len(line)/8+1)*8
282 lenline = (len(line)/8)*8
284 for i in range(lenline/8):
287 if i*8+j < len(line) and line[i*8+j] != "0": byte += "1"
290 bytedata += PackData(byte)
292 for i in range(lenline/8, lenbytes):
293 bytedata += PackData("0")
295 return lenbytes*8, len(lines), bytedata
300 ## Returns a long value from enumeration type
301 # Can be used for CORBA enumerator types like GEOM.shape_type
302 # @param theItem enumeration type
303 # @ingroup l1_geompy_auxiliary
304 def EnumToLong(theItem):
306 Returns a long value from enumeration type
307 Can be used for CORBA enumerator types like geompy.ShapeType
310 theItem enumeration type
313 if hasattr(theItem, "_v"): ret = theItem._v
316 ## Kinds of shape in terms of <VAR>GEOM.GEOM_IKindOfShape.shape_kind</VAR> enumeration
317 # and a list of parameters, describing the shape.
318 # List of parameters, describing the shape:
319 # - COMPOUND: [nb_solids nb_faces nb_edges nb_vertices]
320 # - COMPSOLID: [nb_solids nb_faces nb_edges nb_vertices]
322 # - SHELL: [info.CLOSED / info.UNCLOSED nb_faces nb_edges nb_vertices]
324 # - WIRE: [info.CLOSED / info.UNCLOSED nb_edges nb_vertices]
326 # - SPHERE: [xc yc zc R]
327 # - CYLINDER: [xb yb zb dx dy dz R H]
328 # - BOX: [xc yc zc ax ay az]
329 # - ROTATED_BOX: [xc yc zc zx zy zz xx xy xz ax ay az]
330 # - TORUS: [xc yc zc dx dy dz R_1 R_2]
331 # - CONE: [xb yb zb dx dy dz R_1 R_2 H]
332 # - POLYHEDRON: [nb_faces nb_edges nb_vertices]
333 # - SOLID: [nb_faces nb_edges nb_vertices]
335 # - SPHERE2D: [xc yc zc R]
336 # - CYLINDER2D: [xb yb zb dx dy dz R H]
337 # - TORUS2D: [xc yc zc dx dy dz R_1 R_2]
338 # - CONE2D: [xc yc zc dx dy dz R_1 R_2 H]
339 # - DISK_CIRCLE: [xc yc zc dx dy dz R]
340 # - DISK_ELLIPSE: [xc yc zc dx dy dz R_1 R_2]
341 # - POLYGON: [xo yo zo dx dy dz nb_edges nb_vertices]
342 # - PLANE: [xo yo zo dx dy dz]
343 # - PLANAR: [xo yo zo dx dy dz nb_edges nb_vertices]
344 # - FACE: [nb_edges nb_vertices]
346 # - CIRCLE: [xc yc zc dx dy dz R]
347 # - ARC_CIRCLE: [xc yc zc dx dy dz R x1 y1 z1 x2 y2 z2]
348 # - ELLIPSE: [xc yc zc dx dy dz R_1 R_2]
349 # - ARC_ELLIPSE: [xc yc zc dx dy dz R_1 R_2 x1 y1 z1 x2 y2 z2]
350 # - LINE: [xo yo zo dx dy dz]
351 # - SEGMENT: [x1 y1 z1 x2 y2 z2]
352 # - EDGE: [nb_vertices]
355 # @ingroup l1_geompy_auxiliary
356 kind = GEOM.GEOM_IKindOfShape
358 ## Information about closed/unclosed state of shell or wire
359 # @ingroup l1_geompy_auxiliary
362 Information about closed/unclosed state of shell or wire
368 class geompyDC(GEOM._objref_GEOM_Gen):
371 GEOM._objref_GEOM_Gen.__init__(self)
372 self.myBuilder = None
391 ## @addtogroup l1_geompy_auxiliary
393 def init_geom(self,theStudy):
394 self.myStudy = theStudy
395 self.myStudyId = self.myStudy._get_StudyId()
396 self.myBuilder = self.myStudy.NewBuilder()
397 self.father = self.myStudy.FindComponent("GEOM")
398 if self.father is None:
399 self.father = self.myBuilder.NewComponent("GEOM")
400 A1 = self.myBuilder.FindOrCreateAttribute(self.father, "AttributeName")
401 FName = A1._narrow(SALOMEDS.AttributeName)
402 FName.SetValue("Geometry")
403 A2 = self.myBuilder.FindOrCreateAttribute(self.father, "AttributePixMap")
404 aPixmap = A2._narrow(SALOMEDS.AttributePixMap)
405 aPixmap.SetPixMap("ICON_OBJBROWSER_Geometry")
406 self.myBuilder.DefineComponentInstance(self.father,self)
408 self.BasicOp = self.GetIBasicOperations (self.myStudyId)
409 self.CurvesOp = self.GetICurvesOperations (self.myStudyId)
410 self.PrimOp = self.GetI3DPrimOperations (self.myStudyId)
411 self.ShapesOp = self.GetIShapesOperations (self.myStudyId)
412 self.HealOp = self.GetIHealingOperations (self.myStudyId)
413 self.InsertOp = self.GetIInsertOperations (self.myStudyId)
414 self.BoolOp = self.GetIBooleanOperations (self.myStudyId)
415 self.TrsfOp = self.GetITransformOperations(self.myStudyId)
416 self.LocalOp = self.GetILocalOperations (self.myStudyId)
417 self.MeasuOp = self.GetIMeasureOperations (self.myStudyId)
418 self.BlocksOp = self.GetIBlocksOperations (self.myStudyId)
419 self.GroupOp = self.GetIGroupOperations (self.myStudyId)
420 self.AdvOp = self.GetIAdvancedOperations (self.myStudyId)
423 ## Dump component to the Python script
424 # This method overrides IDL function to allow default values for the parameters.
425 def DumpPython(self, theStudy, theIsPublished=True, theIsMultiFile=True):
427 Dump component to the Python script
428 This method overrides IDL function to allow default values for the parameters.
430 return GEOM._objref_GEOM_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile)
432 ## Get name for sub-shape aSubObj of shape aMainObj
434 # @ref swig_SubShapeName "Example"
435 def SubShapeName(self,aSubObj, aMainObj):
437 Get name for sub-shape aSubObj of shape aMainObj
439 # Example: see GEOM_TestAll.py
441 #aSubId = orb.object_to_string(aSubObj)
442 #aMainId = orb.object_to_string(aMainObj)
443 #index = gg.getIndexTopology(aSubId, aMainId)
444 #name = gg.getShapeTypeString(aSubId) + "_%d"%(index)
445 index = self.ShapesOp.GetTopologyIndex(aMainObj, aSubObj)
446 name = self.ShapesOp.GetShapeTypeString(aSubObj) + "_%d"%(index)
449 ## Publish in study aShape with name aName
451 # \param aShape the shape to be published
452 # \param aName the name for the shape
453 # \param doRestoreSubShapes if True, finds and publishes also
454 # sub-shapes of <VAR>aShape</VAR>, corresponding to its arguments
455 # and published sub-shapes of arguments
456 # \param theArgs,theFindMethod,theInheritFirstArg see RestoreSubShapes() for
457 # these arguments description
458 # \return study entry of the published shape in form of string
460 # @ref swig_all_addtostudy "Example"
461 def addToStudy(self, aShape, aName, doRestoreSubShapes=False,
462 theArgs=[], theFindMethod=GEOM.FSM_GetInPlace, theInheritFirstArg=False):
464 Publish in study aShape with name aName
467 aShape the shape to be published
468 aName the name for the shape
469 doRestoreSubShapes if True, finds and publishes also
470 sub-shapes of aShape, corresponding to its arguments
471 and published sub-shapes of arguments
472 theArgs,theFindMethod,theInheritFirstArg see geompy.RestoreSubShapes() for
473 these arguments description
476 study entry of the published shape in form of string
479 id_block1 = geompy.addToStudy(Block1, "Block 1")
481 # Example: see GEOM_TestAll.py
483 aSObject = self.AddInStudy(self.myStudy, aShape, aName, None)
484 if doRestoreSubShapes:
485 self.RestoreSubShapesSO(self.myStudy, aSObject, theArgs,
486 theFindMethod, theInheritFirstArg, True )
488 print "addToStudy() failed"
490 return aShape.GetStudyEntry()
492 ## Publish in study aShape with name aName as sub-object of previously published aFather
493 # \param aFather previously published object
494 # \param aShape the shape to be published as sub-object of <VAR>aFather</VAR>
495 # \param aName the name for the shape
497 # \return study entry of the published shape in form of string
498 # @ref swig_all_addtostudyInFather "Example"
499 def addToStudyInFather(self, aFather, aShape, aName):
501 Publish in study aShape with name aName as sub-object of previously published aFather
504 aFather previously published object
505 aShape the shape to be published as sub-object of aFather
506 aName the name for the shape
509 study entry of the published shape in form of string
511 # Example: see GEOM_TestAll.py
513 aSObject = self.AddInStudy(self.myStudy, aShape, aName, aFather)
515 print "addToStudyInFather() failed"
517 return aShape.GetStudyEntry()
519 ## Unpublish object in study
521 # \param obj the object to be unpublished
522 def hideInStudy(self, obj):
524 Unpublish object in study
527 obj the object to be unpublished
529 ior = salome.orb.object_to_string(obj)
530 aSObject = self.myStudy.FindObjectIOR(ior)
531 if aSObject is not None:
532 genericAttribute = self.myBuilder.FindOrCreateAttribute(aSObject, "AttributeDrawable")
533 drwAttribute = genericAttribute._narrow(SALOMEDS.AttributeDrawable)
534 drwAttribute.SetDrawable(False)
537 # end of l1_geompy_auxiliary
540 ## @addtogroup l3_restore_ss
543 ## Publish sub-shapes, standing for arguments and sub-shapes of arguments
544 # To be used from python scripts out of addToStudy() (non-default usage)
545 # \param theObject published GEOM.GEOM_Object, arguments of which will be published
546 # \param theArgs list of GEOM.GEOM_Object, operation arguments to be published.
547 # If this list is empty, all operation arguments will be published
548 # \param theFindMethod method to search sub-shapes, corresponding to arguments and
549 # their sub-shapes. Value from enumeration GEOM.find_shape_method.
550 # \param theInheritFirstArg set properties of the first argument for <VAR>theObject</VAR>.
551 # Do not publish sub-shapes in place of arguments, but only
552 # in place of sub-shapes of the first argument,
553 # because the whole shape corresponds to the first argument.
554 # Mainly to be used after transformations, but it also can be
555 # usefull after partition with one object shape, and some other
556 # operations, where only the first argument has to be considered.
557 # If theObject has only one argument shape, this flag is automatically
558 # considered as True, not regarding really passed value.
559 # \param theAddPrefix add prefix "from_" to names of restored sub-shapes,
560 # and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
561 # \return list of published sub-shapes
563 # @ref tui_restore_prs_params "Example"
564 def RestoreSubShapes (self, theObject, theArgs=[], theFindMethod=GEOM.FSM_GetInPlace,
565 theInheritFirstArg=False, theAddPrefix=True):
567 Publish sub-shapes, standing for arguments and sub-shapes of arguments
568 To be used from python scripts out of geompy.addToStudy (non-default usage)
571 theObject published GEOM.GEOM_Object, arguments of which will be published
572 theArgs list of GEOM.GEOM_Object, operation arguments to be published.
573 If this list is empty, all operation arguments will be published
574 theFindMethod method to search sub-shapes, corresponding to arguments and
575 their sub-shapes. Value from enumeration GEOM.find_shape_method.
576 theInheritFirstArg set properties of the first argument for theObject.
577 Do not publish sub-shapes in place of arguments, but only
578 in place of sub-shapes of the first argument,
579 because the whole shape corresponds to the first argument.
580 Mainly to be used after transformations, but it also can be
581 usefull after partition with one object shape, and some other
582 operations, where only the first argument has to be considered.
583 If theObject has only one argument shape, this flag is automatically
584 considered as True, not regarding really passed value.
585 theAddPrefix add prefix "from_" to names of restored sub-shapes,
586 and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
588 list of published sub-shapes
590 # Example: see GEOM_TestAll.py
591 return self.RestoreSubShapesO(self.myStudy, theObject, theArgs,
592 theFindMethod, theInheritFirstArg, theAddPrefix)
594 ## Publish sub-shapes, standing for arguments and sub-shapes of arguments
595 # To be used from python scripts out of addToStudy() (non-default usage)
596 # \param theObject published GEOM.GEOM_Object, arguments of which will be published
597 # \param theArgs list of GEOM.GEOM_Object, operation arguments to be published.
598 # If this list is empty, all operation arguments will be published
599 # \param theFindMethod method to search sub-shapes, corresponding to arguments and
600 # their sub-shapes. Value from enumeration GEOM::find_shape_method.
601 # \param theInheritFirstArg set properties of the first argument for <VAR>theObject</VAR>.
602 # Do not publish sub-shapes in place of arguments, but only
603 # in place of sub-shapes of the first argument,
604 # because the whole shape corresponds to the first argument.
605 # Mainly to be used after transformations, but it also can be
606 # usefull after partition with one object shape, and some other
607 # operations, where only the first argument has to be considered.
608 # If theObject has only one argument shape, this flag is automatically
609 # considered as True, not regarding really passed value.
610 # \param theAddPrefix add prefix "from_" to names of restored sub-shapes,
611 # and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
612 # \return list of published sub-shapes
614 # @ref tui_restore_prs_params "Example"
615 def RestoreGivenSubShapes (self, theObject, theArgs=[], theFindMethod=GEOM.FSM_GetInPlace,
616 theInheritFirstArg=False, theAddPrefix=True):
618 Publish sub-shapes, standing for arguments and sub-shapes of arguments
619 To be used from python scripts out of geompy.addToStudy() (non-default usage)
622 theObject published GEOM.GEOM_Object, arguments of which will be published
623 theArgs list of GEOM.GEOM_Object, operation arguments to be published.
624 If this list is empty, all operation arguments will be published
625 theFindMethod method to search sub-shapes, corresponding to arguments and
626 their sub-shapes. Value from enumeration GEOM::find_shape_method.
627 theInheritFirstArg set properties of the first argument for theObject.
628 Do not publish sub-shapes in place of arguments, but only
629 in place of sub-shapes of the first argument,
630 because the whole shape corresponds to the first argument.
631 Mainly to be used after transformations, but it also can be
632 usefull after partition with one object shape, and some other
633 operations, where only the first argument has to be considered.
634 If theObject has only one argument shape, this flag is automatically
635 considered as True, not regarding really passed value.
636 theAddPrefix add prefix "from_" to names of restored sub-shapes,
637 and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
640 list of published sub-shapes
642 # Example: see GEOM_TestAll.py
643 return self.RestoreGivenSubShapesO(self.myStudy, theObject, theArgs,
644 theFindMethod, theInheritFirstArg, theAddPrefix)
646 # end of l3_restore_ss
649 ## @addtogroup l3_basic_go
652 ## Create point by three coordinates.
653 # @param theX The X coordinate of the point.
654 # @param theY The Y coordinate of the point.
655 # @param theZ The Z coordinate of the point.
656 # @return New GEOM.GEOM_Object, containing the created point.
658 # @ref tui_creation_point "Example"
659 def MakeVertex(self, theX, theY, theZ):
661 Create point by three coordinates.
664 theX The X coordinate of the point.
665 theY The Y coordinate of the point.
666 theZ The Z coordinate of the point.
669 New GEOM.GEOM_Object, containing the created point.
671 # Example: see GEOM_TestAll.py
672 theX,theY,theZ,Parameters = ParseParameters(theX, theY, theZ)
673 anObj = self.BasicOp.MakePointXYZ(theX, theY, theZ)
674 RaiseIfFailed("MakePointXYZ", self.BasicOp)
675 anObj.SetParameters(Parameters)
678 ## Create a point, distant from the referenced point
679 # on the given distances along the coordinate axes.
680 # @param theReference The referenced point.
681 # @param theX Displacement from the referenced point along OX axis.
682 # @param theY Displacement from the referenced point along OY axis.
683 # @param theZ Displacement from the referenced point along OZ axis.
684 # @return New GEOM.GEOM_Object, containing the created point.
686 # @ref tui_creation_point "Example"
687 def MakeVertexWithRef(self,theReference, theX, theY, theZ):
689 Create a point, distant from the referenced point
690 on the given distances along the coordinate axes.
693 theReference The referenced point.
694 theX Displacement from the referenced point along OX axis.
695 theY Displacement from the referenced point along OY axis.
696 theZ Displacement from the referenced point along OZ axis.
699 New GEOM.GEOM_Object, containing the created point.
701 # Example: see GEOM_TestAll.py
702 theX,theY,theZ,Parameters = ParseParameters(theX, theY, theZ)
703 anObj = self.BasicOp.MakePointWithReference(theReference, theX, theY, theZ)
704 RaiseIfFailed("MakePointWithReference", self.BasicOp)
705 anObj.SetParameters(Parameters)
708 ## Create a point, corresponding to the given parameter on the given curve.
709 # @param theRefCurve The referenced curve.
710 # @param theParameter Value of parameter on the referenced curve.
711 # @return New GEOM.GEOM_Object, containing the created point.
713 # @ref tui_creation_point "Example"
714 def MakeVertexOnCurve(self,theRefCurve, theParameter):
716 Create a point, corresponding to the given parameter on the given curve.
719 theRefCurve The referenced curve.
720 theParameter Value of parameter on the referenced curve.
723 New GEOM.GEOM_Object, containing the created point.
726 p_on_arc = geompy.MakeVertexOnCurve(Arc, 0.25)
728 # Example: see GEOM_TestAll.py
729 theParameter, Parameters = ParseParameters(theParameter)
730 anObj = self.BasicOp.MakePointOnCurve(theRefCurve, theParameter)
731 RaiseIfFailed("MakePointOnCurve", self.BasicOp)
732 anObj.SetParameters(Parameters)
735 ## Create a point by projection give coordinates on the given curve
736 # @param theRefCurve The referenced curve.
737 # @param theX X-coordinate in 3D space
738 # @param theY Y-coordinate in 3D space
739 # @param theZ Z-coordinate in 3D space
740 # @return New GEOM.GEOM_Object, containing the created point.
742 # @ref tui_creation_point "Example"
743 def MakeVertexOnCurveByCoord(self,theRefCurve, theX, theY, theZ):
745 Create a point by projection give coordinates on the given curve
748 theRefCurve The referenced curve.
749 theX X-coordinate in 3D space
750 theY Y-coordinate in 3D space
751 theZ Z-coordinate in 3D space
754 New GEOM.GEOM_Object, containing the created point.
757 p_on_arc3 = geompy.MakeVertexOnCurveByCoord(Arc, 100, -10, 10)
759 # Example: see GEOM_TestAll.py
760 theX, theY, theZ, Parameters = ParseParameters(theX, theY, theZ)
761 anObj = self.BasicOp.MakePointOnCurveByCoord(theRefCurve, theX, theY, theZ)
762 RaiseIfFailed("MakeVertexOnCurveByCoord", self.BasicOp)
763 anObj.SetParameters(Parameters)
766 ## Create a point, corresponding to the given length on the given curve.
767 # @param theRefCurve The referenced curve.
768 # @param theLength Length on the referenced curve. It can be negative.
769 # @param theStartPoint Point allowing to choose the direction for the calculation
770 # of the length. If None, start from the first point of theRefCurve.
771 # @return New GEOM.GEOM_Object, containing the created point.
773 # @ref tui_creation_point "Example"
774 def MakeVertexOnCurveByLength(self, theRefCurve, theLength, theStartPoint = None):
776 Create a point, corresponding to the given length on the given curve.
779 theRefCurve The referenced curve.
780 theLength Length on the referenced curve. It can be negative.
781 theStartPoint Point allowing to choose the direction for the calculation
782 of the length. If None, start from the first point of theRefCurve.
785 New GEOM.GEOM_Object, containing the created point.
787 # Example: see GEOM_TestAll.py
788 theLength, Parameters = ParseParameters(theLength)
789 anObj = self.BasicOp.MakePointOnCurveByLength(theRefCurve, theLength, theStartPoint)
790 RaiseIfFailed("MakePointOnCurveByLength", self.BasicOp)
791 anObj.SetParameters(Parameters)
794 ## Create a point, corresponding to the given parameters on the
796 # @param theRefSurf The referenced surface.
797 # @param theUParameter Value of U-parameter on the referenced surface.
798 # @param theVParameter Value of V-parameter on the referenced surface.
799 # @return New GEOM.GEOM_Object, containing the created point.
801 # @ref swig_MakeVertexOnSurface "Example"
802 def MakeVertexOnSurface(self, theRefSurf, theUParameter, theVParameter):
804 Create a point, corresponding to the given parameters on the
808 theRefSurf The referenced surface.
809 theUParameter Value of U-parameter on the referenced surface.
810 theVParameter Value of V-parameter on the referenced surface.
813 New GEOM.GEOM_Object, containing the created point.
816 p_on_face = geompy.MakeVertexOnSurface(Face, 0.1, 0.8) #(GEOM_Object, Double, Double)->GEOM_Object
818 theUParameter, theVParameter, Parameters = ParseParameters(theUParameter, theVParameter)
819 # Example: see GEOM_TestAll.py
820 anObj = self.BasicOp.MakePointOnSurface(theRefSurf, theUParameter, theVParameter)
821 RaiseIfFailed("MakePointOnSurface", self.BasicOp)
822 anObj.SetParameters(Parameters);
825 ## Create a point by projection give coordinates on the given surface
826 # @param theRefSurf The referenced surface.
827 # @param theX X-coordinate in 3D space
828 # @param theY Y-coordinate in 3D space
829 # @param theZ Z-coordinate in 3D space
830 # @return New GEOM.GEOM_Object, containing the created point.
832 # @ref swig_MakeVertexOnSurfaceByCoord "Example"
833 def MakeVertexOnSurfaceByCoord(self, theRefSurf, theX, theY, theZ):
835 Create a point by projection give coordinates on the given surface
838 theRefSurf The referenced surface.
839 theX X-coordinate in 3D space
840 theY Y-coordinate in 3D space
841 theZ Z-coordinate in 3D space
844 New GEOM.GEOM_Object, containing the created point.
847 p_on_face2 = geompy.MakeVertexOnSurfaceByCoord(Face, 0., 0., 0.) #(GEOM_Object, Double, Double, Double)->GEOM_Object
849 theX, theY, theZ, Parameters = ParseParameters(theX, theY, theZ)
850 # Example: see GEOM_TestAll.py
851 anObj = self.BasicOp.MakePointOnSurfaceByCoord(theRefSurf, theX, theY, theZ)
852 RaiseIfFailed("MakeVertexOnSurfaceByCoord", self.BasicOp)
853 anObj.SetParameters(Parameters);
856 ## Create a point on intersection of two lines.
857 # @param theRefLine1, theRefLine2 The referenced lines.
858 # @return New GEOM.GEOM_Object, containing the created point.
860 # @ref swig_MakeVertexOnLinesIntersection "Example"
861 def MakeVertexOnLinesIntersection(self, theRefLine1, theRefLine2):
863 Create a point on intersection of two lines.
866 theRefLine1, theRefLine2 The referenced lines.
869 New GEOM.GEOM_Object, containing the created point.
871 # Example: see GEOM_TestAll.py
872 anObj = self.BasicOp.MakePointOnLinesIntersection(theRefLine1, theRefLine2)
873 RaiseIfFailed("MakePointOnLinesIntersection", self.BasicOp)
876 ## Create a tangent, corresponding to the given parameter on the given curve.
877 # @param theRefCurve The referenced curve.
878 # @param theParameter Value of parameter on the referenced curve.
879 # @return New GEOM.GEOM_Object, containing the created tangent.
881 # @ref swig_MakeTangentOnCurve "Example"
882 def MakeTangentOnCurve(self, theRefCurve, theParameter):
884 Create a tangent, corresponding to the given parameter on the given curve.
887 theRefCurve The referenced curve.
888 theParameter Value of parameter on the referenced curve.
891 New GEOM.GEOM_Object, containing the created tangent.
894 tan_on_arc = geompy.MakeTangentOnCurve(Arc, 0.7) #(GEOM_Object, Double)->GEOM_Object
896 anObj = self.BasicOp.MakeTangentOnCurve(theRefCurve, theParameter)
897 RaiseIfFailed("MakeTangentOnCurve", self.BasicOp)
900 ## Create a tangent plane, corresponding to the given parameter on the given face.
901 # @param theFace The face for which tangent plane should be built.
902 # @param theParameterV vertical value of the center point (0.0 - 1.0).
903 # @param theParameterU horisontal value of the center point (0.0 - 1.0).
904 # @param theTrimSize the size of plane.
905 # @return New GEOM.GEOM_Object, containing the created tangent.
907 # @ref swig_MakeTangentPlaneOnFace "Example"
908 def MakeTangentPlaneOnFace(self, theFace, theParameterU, theParameterV, theTrimSize):
910 Create a tangent plane, corresponding to the given parameter on the given face.
913 theFace The face for which tangent plane should be built.
914 theParameterV vertical value of the center point (0.0 - 1.0).
915 theParameterU horisontal value of the center point (0.0 - 1.0).
916 theTrimSize the size of plane.
919 New GEOM.GEOM_Object, containing the created tangent.
922 an_on_face = geompy.MakeTangentPlaneOnFace(tan_extrusion, 0.7, 0.5, 150)
924 anObj = self.BasicOp.MakeTangentPlaneOnFace(theFace, theParameterU, theParameterV, theTrimSize)
925 RaiseIfFailed("MakeTangentPlaneOnFace", self.BasicOp)
928 ## Create a vector with the given components.
929 # @param theDX X component of the vector.
930 # @param theDY Y component of the vector.
931 # @param theDZ Z component of the vector.
932 # @return New GEOM.GEOM_Object, containing the created vector.
934 # @ref tui_creation_vector "Example"
935 def MakeVectorDXDYDZ(self,theDX, theDY, theDZ):
937 Create a vector with the given components.
940 theDX X component of the vector.
941 theDY Y component of the vector.
942 theDZ Z component of the vector.
945 New GEOM.GEOM_Object, containing the created vector.
947 # Example: see GEOM_TestAll.py
948 theDX,theDY,theDZ,Parameters = ParseParameters(theDX, theDY, theDZ)
949 anObj = self.BasicOp.MakeVectorDXDYDZ(theDX, theDY, theDZ)
950 RaiseIfFailed("MakeVectorDXDYDZ", self.BasicOp)
951 anObj.SetParameters(Parameters)
954 ## Create a vector between two points.
955 # @param thePnt1 Start point for the vector.
956 # @param thePnt2 End point for the vector.
957 # @return New GEOM.GEOM_Object, containing the created vector.
959 # @ref tui_creation_vector "Example"
960 def MakeVector(self,thePnt1, thePnt2):
962 Create a vector between two points.
965 thePnt1 Start point for the vector.
966 thePnt2 End point for the vector.
969 New GEOM.GEOM_Object, containing the created vector.
971 # Example: see GEOM_TestAll.py
972 anObj = self.BasicOp.MakeVectorTwoPnt(thePnt1, thePnt2)
973 RaiseIfFailed("MakeVectorTwoPnt", self.BasicOp)
976 ## Create a line, passing through the given point
977 # and parrallel to the given direction
978 # @param thePnt Point. The resulting line will pass through it.
979 # @param theDir Direction. The resulting line will be parallel to it.
980 # @return New GEOM.GEOM_Object, containing the created line.
982 # @ref tui_creation_line "Example"
983 def MakeLine(self,thePnt, theDir):
985 Create a line, passing through the given point
986 and parrallel to the given direction
989 thePnt Point. The resulting line will pass through it.
990 theDir Direction. The resulting line will be parallel to it.
993 New GEOM.GEOM_Object, containing the created line.
995 # Example: see GEOM_TestAll.py
996 anObj = self.BasicOp.MakeLine(thePnt, theDir)
997 RaiseIfFailed("MakeLine", self.BasicOp)
1000 ## Create a line, passing through the given points
1001 # @param thePnt1 First of two points, defining the line.
1002 # @param thePnt2 Second of two points, defining the line.
1003 # @return New GEOM.GEOM_Object, containing the created line.
1005 # @ref tui_creation_line "Example"
1006 def MakeLineTwoPnt(self,thePnt1, thePnt2):
1008 Create a line, passing through the given points
1011 thePnt1 First of two points, defining the line.
1012 thePnt2 Second of two points, defining the line.
1015 New GEOM.GEOM_Object, containing the created line.
1017 # Example: see GEOM_TestAll.py
1018 anObj = self.BasicOp.MakeLineTwoPnt(thePnt1, thePnt2)
1019 RaiseIfFailed("MakeLineTwoPnt", self.BasicOp)
1022 ## Create a line on two faces intersection.
1023 # @param theFace1 First of two faces, defining the line.
1024 # @param theFace2 Second of two faces, defining the line.
1025 # @return New GEOM.GEOM_Object, containing the created line.
1027 # @ref swig_MakeLineTwoFaces "Example"
1028 def MakeLineTwoFaces(self, theFace1, theFace2):
1030 Create a line on two faces intersection.
1033 theFace1 First of two faces, defining the line.
1034 theFace2 Second of two faces, defining the line.
1037 New GEOM.GEOM_Object, containing the created line.
1039 # Example: see GEOM_TestAll.py
1040 anObj = self.BasicOp.MakeLineTwoFaces(theFace1, theFace2)
1041 RaiseIfFailed("MakeLineTwoFaces", self.BasicOp)
1044 ## Create a plane, passing through the given point
1045 # and normal to the given vector.
1046 # @param thePnt Point, the plane has to pass through.
1047 # @param theVec Vector, defining the plane normal direction.
1048 # @param theTrimSize Half size of a side of quadrangle face, representing the plane.
1049 # @return New GEOM.GEOM_Object, containing the created plane.
1051 # @ref tui_creation_plane "Example"
1052 def MakePlane(self,thePnt, theVec, theTrimSize):
1054 Create a plane, passing through the given point
1055 and normal to the given vector.
1058 thePnt Point, the plane has to pass through.
1059 theVec Vector, defining the plane normal direction.
1060 theTrimSize Half size of a side of quadrangle face, representing the plane.
1063 New GEOM.GEOM_Object, containing the created plane.
1065 # Example: see GEOM_TestAll.py
1066 theTrimSize, Parameters = ParseParameters(theTrimSize);
1067 anObj = self.BasicOp.MakePlanePntVec(thePnt, theVec, theTrimSize)
1068 RaiseIfFailed("MakePlanePntVec", self.BasicOp)
1069 anObj.SetParameters(Parameters)
1072 ## Create a plane, passing through the three given points
1073 # @param thePnt1 First of three points, defining the plane.
1074 # @param thePnt2 Second of three points, defining the plane.
1075 # @param thePnt3 Fird of three points, defining the plane.
1076 # @param theTrimSize Half size of a side of quadrangle face, representing the plane.
1077 # @return New GEOM.GEOM_Object, containing the created plane.
1079 # @ref tui_creation_plane "Example"
1080 def MakePlaneThreePnt(self,thePnt1, thePnt2, thePnt3, theTrimSize):
1082 Create a plane, passing through the three given points
1085 thePnt1 First of three points, defining the plane.
1086 thePnt2 Second of three points, defining the plane.
1087 thePnt3 Fird of three points, defining the plane.
1088 theTrimSize Half size of a side of quadrangle face, representing the plane.
1091 New GEOM.GEOM_Object, containing the created plane.
1093 # Example: see GEOM_TestAll.py
1094 theTrimSize, Parameters = ParseParameters(theTrimSize);
1095 anObj = self.BasicOp.MakePlaneThreePnt(thePnt1, thePnt2, thePnt3, theTrimSize)
1096 RaiseIfFailed("MakePlaneThreePnt", self.BasicOp)
1097 anObj.SetParameters(Parameters)
1100 ## Create a plane, similar to the existing one, but with another size of representing face.
1101 # @param theFace Referenced plane or LCS(Marker).
1102 # @param theTrimSize New half size of a side of quadrangle face, representing the plane.
1103 # @return New GEOM.GEOM_Object, containing the created plane.
1105 # @ref tui_creation_plane "Example"
1106 def MakePlaneFace(self,theFace, theTrimSize):
1108 Create a plane, similar to the existing one, but with another size of representing face.
1111 theFace Referenced plane or LCS(Marker).
1112 theTrimSize New half size of a side of quadrangle face, representing the plane.
1115 New GEOM.GEOM_Object, containing the created plane.
1117 # Example: see GEOM_TestAll.py
1118 theTrimSize, Parameters = ParseParameters(theTrimSize);
1119 anObj = self.BasicOp.MakePlaneFace(theFace, theTrimSize)
1120 RaiseIfFailed("MakePlaneFace", self.BasicOp)
1121 anObj.SetParameters(Parameters)
1124 ## Create a plane, passing through the 2 vectors
1125 # with center in a start point of the first vector.
1126 # @param theVec1 Vector, defining center point and plane direction.
1127 # @param theVec2 Vector, defining the plane normal direction.
1128 # @param theTrimSize Half size of a side of quadrangle face, representing the plane.
1129 # @return New GEOM.GEOM_Object, containing the created plane.
1131 # @ref tui_creation_plane "Example"
1132 def MakePlane2Vec(self,theVec1, theVec2, theTrimSize):
1134 Create a plane, passing through the 2 vectors
1135 with center in a start point of the first vector.
1138 theVec1 Vector, defining center point and plane direction.
1139 theVec2 Vector, defining the plane normal direction.
1140 theTrimSize Half size of a side of quadrangle face, representing the plane.
1143 New GEOM.GEOM_Object, containing the created plane.
1145 # Example: see GEOM_TestAll.py
1146 theTrimSize, Parameters = ParseParameters(theTrimSize);
1147 anObj = self.BasicOp.MakePlane2Vec(theVec1, theVec2, theTrimSize)
1148 RaiseIfFailed("MakePlane2Vec", self.BasicOp)
1149 anObj.SetParameters(Parameters)
1152 ## Create a plane, based on a Local coordinate system.
1153 # @param theLCS coordinate system, defining plane.
1154 # @param theTrimSize Half size of a side of quadrangle face, representing the plane.
1155 # @param theOrientation OXY, OYZ or OZX orientation - (1, 2 or 3)
1156 # @return New GEOM.GEOM_Object, containing the created plane.
1158 # @ref tui_creation_plane "Example"
1159 def MakePlaneLCS(self,theLCS, theTrimSize, theOrientation):
1161 Create a plane, based on a Local coordinate system.
1164 theLCS coordinate system, defining plane.
1165 theTrimSize Half size of a side of quadrangle face, representing the plane.
1166 theOrientation OXY, OYZ or OZX orientation - (1, 2 or 3)
1169 New GEOM.GEOM_Object, containing the created plane.
1171 # Example: see GEOM_TestAll.py
1172 theTrimSize, Parameters = ParseParameters(theTrimSize);
1173 anObj = self.BasicOp.MakePlaneLCS(theLCS, theTrimSize, theOrientation)
1174 RaiseIfFailed("MakePlaneLCS", self.BasicOp)
1175 anObj.SetParameters(Parameters)
1178 ## Create a local coordinate system.
1179 # @param OX,OY,OZ Three coordinates of coordinate system origin.
1180 # @param XDX,XDY,XDZ Three components of OX direction
1181 # @param YDX,YDY,YDZ Three components of OY direction
1182 # @return New GEOM.GEOM_Object, containing the created coordinate system.
1184 # @ref swig_MakeMarker "Example"
1185 def MakeMarker(self, OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ):
1187 Create a local coordinate system.
1190 OX,OY,OZ Three coordinates of coordinate system origin.
1191 XDX,XDY,XDZ Three components of OX direction
1192 YDX,YDY,YDZ Three components of OY direction
1195 New GEOM.GEOM_Object, containing the created coordinate system.
1197 # Example: see GEOM_TestAll.py
1198 OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ, Parameters = ParseParameters(OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ);
1199 anObj = self.BasicOp.MakeMarker(OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ)
1200 RaiseIfFailed("MakeMarker", self.BasicOp)
1201 anObj.SetParameters(Parameters)
1204 ## Create a local coordinate system from shape.
1205 # @param theShape The initial shape to detect the coordinate system.
1206 # @return New GEOM.GEOM_Object, containing the created coordinate system.
1208 # @ref tui_creation_lcs "Example"
1209 def MakeMarkerFromShape(self, theShape):
1211 Create a local coordinate system from shape.
1214 theShape The initial shape to detect the coordinate system.
1217 New GEOM.GEOM_Object, containing the created coordinate system.
1219 anObj = self.BasicOp.MakeMarkerFromShape(theShape)
1220 RaiseIfFailed("MakeMarkerFromShape", self.BasicOp)
1223 ## Create a local coordinate system from point and two vectors.
1224 # @param theOrigin Point of coordinate system origin.
1225 # @param theXVec Vector of X direction
1226 # @param theYVec Vector of Y direction
1227 # @return New GEOM.GEOM_Object, containing the created coordinate system.
1229 # @ref tui_creation_lcs "Example"
1230 def MakeMarkerPntTwoVec(self, theOrigin, theXVec, theYVec):
1232 Create a local coordinate system from point and two vectors.
1235 theOrigin Point of coordinate system origin.
1236 theXVec Vector of X direction
1237 theYVec Vector of Y direction
1240 New GEOM.GEOM_Object, containing the created coordinate system.
1243 anObj = self.BasicOp.MakeMarkerPntTwoVec(theOrigin, theXVec, theYVec)
1244 RaiseIfFailed("MakeMarkerPntTwoVec", self.BasicOp)
1247 # end of l3_basic_go
1250 ## @addtogroup l4_curves
1253 ## Create an arc of circle, passing through three given points.
1254 # @param thePnt1 Start point of the arc.
1255 # @param thePnt2 Middle point of the arc.
1256 # @param thePnt3 End point of the arc.
1257 # @return New GEOM.GEOM_Object, containing the created arc.
1259 # @ref swig_MakeArc "Example"
1260 def MakeArc(self,thePnt1, thePnt2, thePnt3):
1262 Create an arc of circle, passing through three given points.
1265 thePnt1 Start point of the arc.
1266 thePnt2 Middle point of the arc.
1267 thePnt3 End point of the arc.
1270 New GEOM.GEOM_Object, containing the created arc.
1272 # Example: see GEOM_TestAll.py
1273 anObj = self.CurvesOp.MakeArc(thePnt1, thePnt2, thePnt3)
1274 RaiseIfFailed("MakeArc", self.CurvesOp)
1277 ## Create an arc of circle from a center and 2 points.
1278 # @param thePnt1 Center of the arc
1279 # @param thePnt2 Start point of the arc. (Gives also the radius of the arc)
1280 # @param thePnt3 End point of the arc (Gives also a direction)
1281 # @param theSense Orientation of the arc
1282 # @return New GEOM.GEOM_Object, containing the created arc.
1284 # @ref swig_MakeArc "Example"
1285 def MakeArcCenter(self, thePnt1, thePnt2, thePnt3, theSense=False):
1287 Create an arc of circle from a center and 2 points.
1290 thePnt1 Center of the arc
1291 thePnt2 Start point of the arc. (Gives also the radius of the arc)
1292 thePnt3 End point of the arc (Gives also a direction)
1293 theSense Orientation of the arc
1296 New GEOM.GEOM_Object, containing the created arc.
1298 # Example: see GEOM_TestAll.py
1299 anObj = self.CurvesOp.MakeArcCenter(thePnt1, thePnt2, thePnt3, theSense)
1300 RaiseIfFailed("MakeArcCenter", self.CurvesOp)
1303 ## Create an arc of ellipse, of center and two points.
1304 # @param theCenter Center of the arc.
1305 # @param thePnt1 defines major radius of the arc by distance from Pnt1 to Pnt2.
1306 # @param thePnt2 defines plane of ellipse and minor radius as distance from Pnt3 to line from Pnt1 to Pnt2.
1307 # @return New GEOM.GEOM_Object, containing the created arc.
1309 # @ref swig_MakeArc "Example"
1310 def MakeArcOfEllipse(self,theCenter, thePnt1, thePnt2):
1312 Create an arc of ellipse, of center and two points.
1315 theCenter Center of the arc.
1316 thePnt1 defines major radius of the arc by distance from Pnt1 to Pnt2.
1317 thePnt2 defines plane of ellipse and minor radius as distance from Pnt3 to line from Pnt1 to Pnt2.
1320 New GEOM.GEOM_Object, containing the created arc.
1322 # Example: see GEOM_TestAll.py
1323 anObj = self.CurvesOp.MakeArcOfEllipse(theCenter, thePnt1, thePnt2)
1324 RaiseIfFailed("MakeArcOfEllipse", self.CurvesOp)
1327 ## Create a circle with given center, normal vector and radius.
1328 # @param thePnt Circle center.
1329 # @param theVec Vector, normal to the plane of the circle.
1330 # @param theR Circle radius.
1331 # @return New GEOM.GEOM_Object, containing the created circle.
1333 # @ref tui_creation_circle "Example"
1334 def MakeCircle(self, thePnt, theVec, theR):
1336 Create a circle with given center, normal vector and radius.
1339 thePnt Circle center.
1340 theVec Vector, normal to the plane of the circle.
1344 New GEOM.GEOM_Object, containing the created circle.
1346 # Example: see GEOM_TestAll.py
1347 theR, Parameters = ParseParameters(theR)
1348 anObj = self.CurvesOp.MakeCirclePntVecR(thePnt, theVec, theR)
1349 RaiseIfFailed("MakeCirclePntVecR", self.CurvesOp)
1350 anObj.SetParameters(Parameters)
1353 ## Create a circle with given radius.
1354 # Center of the circle will be in the origin of global
1355 # coordinate system and normal vector will be codirected with Z axis
1356 # @param theR Circle radius.
1357 # @return New GEOM.GEOM_Object, containing the created circle.
1358 def MakeCircleR(self, theR):
1360 Create a circle with given radius.
1361 Center of the circle will be in the origin of global
1362 coordinate system and normal vector will be codirected with Z axis
1368 New GEOM.GEOM_Object, containing the created circle.
1370 anObj = self.CurvesOp.MakeCirclePntVecR(None, None, theR)
1371 RaiseIfFailed("MakeCirclePntVecR", self.CurvesOp)
1374 ## Create a circle, passing through three given points
1375 # @param thePnt1,thePnt2,thePnt3 Points, defining the circle.
1376 # @return New GEOM.GEOM_Object, containing the created circle.
1378 # @ref tui_creation_circle "Example"
1379 def MakeCircleThreePnt(self,thePnt1, thePnt2, thePnt3):
1381 Create a circle, passing through three given points
1384 thePnt1,thePnt2,thePnt3 Points, defining the circle.
1387 New GEOM.GEOM_Object, containing the created circle.
1389 # Example: see GEOM_TestAll.py
1390 anObj = self.CurvesOp.MakeCircleThreePnt(thePnt1, thePnt2, thePnt3)
1391 RaiseIfFailed("MakeCircleThreePnt", self.CurvesOp)
1394 ## Create a circle, with given point1 as center,
1395 # passing through the point2 as radius and laying in the plane,
1396 # defined by all three given points.
1397 # @param thePnt1,thePnt2,thePnt3 Points, defining the circle.
1398 # @return New GEOM.GEOM_Object, containing the created circle.
1400 # @ref swig_MakeCircle "Example"
1401 def MakeCircleCenter2Pnt(self,thePnt1, thePnt2, thePnt3):
1403 Create a circle, with given point1 as center,
1404 passing through the point2 as radius and laying in the plane,
1405 defined by all three given points.
1408 thePnt1,thePnt2,thePnt3 Points, defining the circle.
1411 New GEOM.GEOM_Object, containing the created circle.
1413 # Example: see GEOM_example6.py
1414 anObj = self.CurvesOp.MakeCircleCenter2Pnt(thePnt1, thePnt2, thePnt3)
1415 RaiseIfFailed("MakeCircleCenter2Pnt", self.CurvesOp)
1418 ## Create an ellipse with given center, normal vector and radiuses.
1419 # @param thePnt Ellipse center.
1420 # @param theVec Vector, normal to the plane of the ellipse.
1421 # @param theRMajor Major ellipse radius.
1422 # @param theRMinor Minor ellipse radius.
1423 # @param theVecMaj Vector, direction of the ellipse's main axis.
1424 # @return New GEOM.GEOM_Object, containing the created ellipse.
1426 # @ref tui_creation_ellipse "Example"
1427 def MakeEllipse(self, thePnt, theVec, theRMajor, theRMinor, theVecMaj=None):
1429 Create an ellipse with given center, normal vector and radiuses.
1432 thePnt Ellipse center.
1433 theVec Vector, normal to the plane of the ellipse.
1434 theRMajor Major ellipse radius.
1435 theRMinor Minor ellipse radius.
1436 theVecMaj Vector, direction of the ellipse's main axis.
1439 New GEOM.GEOM_Object, containing the created ellipse.
1441 # Example: see GEOM_TestAll.py
1442 theRMajor, theRMinor, Parameters = ParseParameters(theRMajor, theRMinor)
1443 if theVecMaj is not None:
1444 anObj = self.CurvesOp.MakeEllipseVec(thePnt, theVec, theRMajor, theRMinor, theVecMaj)
1446 anObj = self.CurvesOp.MakeEllipse(thePnt, theVec, theRMajor, theRMinor)
1448 RaiseIfFailed("MakeEllipse", self.CurvesOp)
1449 anObj.SetParameters(Parameters)
1452 ## Create an ellipse with given radiuses.
1453 # Center of the ellipse will be in the origin of global
1454 # coordinate system and normal vector will be codirected with Z axis
1455 # @param theRMajor Major ellipse radius.
1456 # @param theRMinor Minor ellipse radius.
1457 # @return New GEOM.GEOM_Object, containing the created ellipse.
1458 def MakeEllipseRR(self, theRMajor, theRMinor):
1460 Create an ellipse with given radiuses.
1461 Center of the ellipse will be in the origin of global
1462 coordinate system and normal vector will be codirected with Z axis
1465 theRMajor Major ellipse radius.
1466 theRMinor Minor ellipse radius.
1469 New GEOM.GEOM_Object, containing the created ellipse.
1471 anObj = self.CurvesOp.MakeEllipse(None, None, theRMajor, theRMinor)
1472 RaiseIfFailed("MakeEllipse", self.CurvesOp)
1475 ## Create a polyline on the set of points.
1476 # @param thePoints Sequence of points for the polyline.
1477 # @param theIsClosed If True, build a closed wire.
1478 # @return New GEOM.GEOM_Object, containing the created polyline.
1480 # @ref tui_creation_curve "Example"
1481 def MakePolyline(self, thePoints, theIsClosed=False):
1483 Create a polyline on the set of points.
1486 thePoints Sequence of points for the polyline.
1487 theIsClosed If True, build a closed wire.
1490 New GEOM.GEOM_Object, containing the created polyline.
1492 # Example: see GEOM_TestAll.py
1493 anObj = self.CurvesOp.MakePolyline(thePoints, theIsClosed)
1494 RaiseIfFailed("MakePolyline", self.CurvesOp)
1497 ## Create bezier curve on the set of points.
1498 # @param thePoints Sequence of points for the bezier curve.
1499 # @param theIsClosed If True, build a closed curve.
1500 # @return New GEOM.GEOM_Object, containing the created bezier curve.
1502 # @ref tui_creation_curve "Example"
1503 def MakeBezier(self, thePoints, theIsClosed=False):
1505 Create bezier curve on the set of points.
1508 thePoints Sequence of points for the bezier curve.
1509 theIsClosed If True, build a closed curve.
1512 New GEOM.GEOM_Object, containing the created bezier curve.
1514 # Example: see GEOM_TestAll.py
1515 anObj = self.CurvesOp.MakeSplineBezier(thePoints, theIsClosed)
1516 RaiseIfFailed("MakeSplineBezier", self.CurvesOp)
1519 ## Create B-Spline curve on the set of points.
1520 # @param thePoints Sequence of points for the B-Spline curve.
1521 # @param theIsClosed If True, build a closed curve.
1522 # @param theDoReordering If TRUE, the algo does not follow the order of
1523 # \a thePoints but searches for the closest vertex.
1524 # @return New GEOM.GEOM_Object, containing the created B-Spline curve.
1526 # @ref tui_creation_curve "Example"
1527 def MakeInterpol(self, thePoints, theIsClosed=False, theDoReordering=False):
1529 Create B-Spline curve on the set of points.
1532 thePoints Sequence of points for the B-Spline curve.
1533 theIsClosed If True, build a closed curve.
1534 theDoReordering If True, the algo does not follow the order of
1535 thePoints but searches for the closest vertex.
1538 New GEOM.GEOM_Object, containing the created B-Spline curve.
1540 # Example: see GEOM_TestAll.py
1541 anObj = self.CurvesOp.MakeSplineInterpolation(thePoints, theIsClosed, theDoReordering)
1542 RaiseIfFailed("MakeSplineInterpolation", self.CurvesOp)
1546 ## Creates a curve using the parametric definition of the basic points.
1547 # @param thexExpr parametric equation of the coordinates X.
1548 # @param theyExpr parametric equation of the coordinates Y.
1549 # @param thezExpr parametric equation of the coordinates Z.
1550 # @param theParamMin the minimal value of the parameter.
1551 # @param theParamMax the maximum value of the parameter.
1552 # @param theParamStep the number of steps if theNewMethod = True, else step value of the parameter.
1553 # @param theCurveType the type of the curve.
1554 # @param theNewMethod flag for switching to the new method if the flag is set to false a deprecated method is used which can lead to a bug.
1555 # @return New GEOM.GEOM_Object, containing the created curve.
1557 # @ref tui_creation_curve "Example"
1558 def MakeCurveParametric(self, thexExpr, theyExpr, thezExpr,
1559 theParamMin, theParamMax, theParamStep, theCurveType, theNewMethod=False ):
1561 Creates a curve using the parametric definition of the basic points.
1564 thexExpr parametric equation of the coordinates X.
1565 theyExpr parametric equation of the coordinates Y.
1566 thezExpr parametric equation of the coordinates Z.
1567 theParamMin the minimal value of the parameter.
1568 theParamMax the maximum value of the parameter.
1569 theParamStep the number of steps if theNewMethod = True, else step value of the parameter.
1570 theCurveType the type of the curve.
1571 theNewMethod flag for switching to the new method if the flag is set to false a deprecated
1572 method is used which can lead to a bug.
1575 New GEOM.GEOM_Object, containing the created curve.
1577 theParamMin,theParamMax,theParamStep,Parameters = ParseParameters(theParamMin,theParamMax,theParamStep)
1579 anObj = self.CurvesOp.MakeCurveParametricNew(thexExpr,theyExpr,thezExpr,theParamMin,theParamMax,theParamStep,theCurveType)
1581 anObj = self.CurvesOp.MakeCurveParametric(thexExpr,theyExpr,thezExpr,theParamMin,theParamMax,theParamStep,theCurveType)
1582 RaiseIfFailed("MakeSplineInterpolation", self.CurvesOp)
1583 anObj.SetParameters(Parameters)
1591 ## @addtogroup l3_sketcher
1594 ## Create a sketcher (wire or face), following the textual description,
1595 # passed through <VAR>theCommand</VAR> argument. \n
1596 # Edges of the resulting wire or face will be arcs of circles and/or linear segments. \n
1597 # Format of the description string have to be the following:
1599 # "Sketcher[:F x1 y1]:CMD[:CMD[:CMD...]]"
1602 # - x1, y1 are coordinates of the first sketcher point (zero by default),
1604 # - "R angle" : Set the direction by angle
1605 # - "D dx dy" : Set the direction by DX & DY
1608 # - "TT x y" : Create segment by point at X & Y
1609 # - "T dx dy" : Create segment by point with DX & DY
1610 # - "L length" : Create segment by direction & Length
1611 # - "IX x" : Create segment by direction & Intersect. X
1612 # - "IY y" : Create segment by direction & Intersect. Y
1615 # - "C radius length" : Create arc by direction, radius and length(in degree)
1616 # - "AA x y": Create arc by point at X & Y
1617 # - "A dx dy" : Create arc by point with DX & DY
1618 # - "A dx dy" : Create arc by point with DX & DY
1619 # - "UU x y radius flag1": Create arc by point at X & Y with given radiUs
1620 # - "U dx dy radius flag1" : Create arc by point with DX & DY with given radiUs
1621 # - "EE x y xc yc flag1 flag2": Create arc by point at X & Y with given cEnter coordinates
1622 # - "E dx dy dxc dyc radius flag1 flag2" : Create arc by point with DX & DY with given cEnter coordinates
1625 # - "WW" : Close Wire (to finish)
1626 # - "WF" : Close Wire and build face (to finish)
1629 # - Flag1 (= reverse) is 0 or 2 ...
1630 # - if 0 the drawn arc is the one of lower angle (< Pi)
1631 # - if 2 the drawn arc ius the one of greater angle (> Pi)
1634 # - Flag2 (= control tolerance) is 0 or 1 ...
1635 # - if 0 the specified end point can be at a distance of the arc greater than the tolerance (10^-7)
1636 # - if 1 the wire is built only if the end point is on the arc
1637 # with a tolerance of 10^-7 on the distance else the creation fails
1639 # @param theCommand String, defining the sketcher in local
1640 # coordinates of the working plane.
1641 # @param theWorkingPlane Nine double values, defining origin,
1642 # OZ and OX directions of the working plane.
1643 # @return New GEOM.GEOM_Object, containing the created wire.
1645 # @ref tui_sketcher_page "Example"
1646 def MakeSketcher(self, theCommand, theWorkingPlane = [0,0,0, 0,0,1, 1,0,0]):
1648 Create a sketcher (wire or face), following the textual description, passed
1649 through theCommand argument.
1650 Edges of the resulting wire or face will be arcs of circles and/or linear segments.
1651 Format of the description string have to be the following:
1652 "Sketcher[:F x1 y1]:CMD[:CMD[:CMD...]]"
1654 - x1, y1 are coordinates of the first sketcher point (zero by default),
1656 - "R angle" : Set the direction by angle
1657 - "D dx dy" : Set the direction by DX & DY
1659 - "TT x y" : Create segment by point at X & Y
1660 - "T dx dy" : Create segment by point with DX & DY
1661 - "L length" : Create segment by direction & Length
1662 - "IX x" : Create segment by direction & Intersect. X
1663 - "IY y" : Create segment by direction & Intersect. Y
1665 - "C radius length" : Create arc by direction, radius and length(in degree)
1666 - "AA x y": Create arc by point at X & Y
1667 - "A dx dy" : Create arc by point with DX & DY
1668 - "A dx dy" : Create arc by point with DX & DY
1669 - "UU x y radius flag1": Create arc by point at X & Y with given radiUs
1670 - "U dx dy radius flag1" : Create arc by point with DX & DY with given radiUs
1671 - "EE x y xc yc flag1 flag2": Create arc by point at X & Y with given cEnter coordinates
1672 - "E dx dy dxc dyc radius flag1 flag2" : Create arc by point with DX & DY with given cEnter coordinates
1674 - "WW" : Close Wire (to finish)
1675 - "WF" : Close Wire and build face (to finish)
1677 - Flag1 (= reverse) is 0 or 2 ...
1678 - if 0 the drawn arc is the one of lower angle (< Pi)
1679 - if 2 the drawn arc ius the one of greater angle (> Pi)
1681 - Flag2 (= control tolerance) is 0 or 1 ...
1682 - if 0 the specified end point can be at a distance of the arc greater than the tolerance (10^-7)
1683 - if 1 the wire is built only if the end point is on the arc
1684 with a tolerance of 10^-7 on the distance else the creation fails
1687 theCommand String, defining the sketcher in local
1688 coordinates of the working plane.
1689 theWorkingPlane Nine double values, defining origin,
1690 OZ and OX directions of the working plane.
1693 New GEOM.GEOM_Object, containing the created wire.
1695 # Example: see GEOM_TestAll.py
1696 theCommand,Parameters = ParseSketcherCommand(theCommand)
1697 anObj = self.CurvesOp.MakeSketcher(theCommand, theWorkingPlane)
1698 RaiseIfFailed("MakeSketcher", self.CurvesOp)
1699 anObj.SetParameters(Parameters)
1702 ## Create a sketcher (wire or face), following the textual description,
1703 # passed through <VAR>theCommand</VAR> argument. \n
1704 # For format of the description string see MakeSketcher() method.\n
1705 # @param theCommand String, defining the sketcher in local
1706 # coordinates of the working plane.
1707 # @param theWorkingPlane Planar Face or LCS(Marker) of the working plane.
1708 # @return New GEOM.GEOM_Object, containing the created wire.
1710 # @ref tui_sketcher_page "Example"
1711 def MakeSketcherOnPlane(self, theCommand, theWorkingPlane):
1713 Create a sketcher (wire or face), following the textual description,
1714 passed through theCommand argument.
1715 For format of the description string see geompy.MakeSketcher() method.
1718 theCommand String, defining the sketcher in local
1719 coordinates of the working plane.
1720 theWorkingPlane Planar Face or LCS(Marker) of the working plane.
1723 New GEOM.GEOM_Object, containing the created wire.
1725 anObj = self.CurvesOp.MakeSketcherOnPlane(theCommand, theWorkingPlane)
1726 RaiseIfFailed("MakeSketcherOnPlane", self.CurvesOp)
1729 ## Create a sketcher wire, following the numerical description,
1730 # passed through <VAR>theCoordinates</VAR> argument. \n
1731 # @param theCoordinates double values, defining points to create a wire,
1733 # @return New GEOM.GEOM_Object, containing the created wire.
1735 # @ref tui_sketcher_page "Example"
1736 def Make3DSketcher(self, theCoordinates):
1738 Create a sketcher wire, following the numerical description,
1739 passed through theCoordinates argument.
1742 theCoordinates double values, defining points to create a wire,
1746 New GEOM_Object, containing the created wire.
1748 theCoordinates,Parameters = ParseParameters(theCoordinates)
1749 anObj = self.CurvesOp.Make3DSketcher(theCoordinates)
1750 RaiseIfFailed("Make3DSketcher", self.CurvesOp)
1751 anObj.SetParameters(Parameters)
1754 # end of l3_sketcher
1757 ## @addtogroup l3_3d_primitives
1760 ## Create a box by coordinates of two opposite vertices.
1762 # @param x1,y1,z1 double values, defining first point it.
1763 # @param x2,y2,z2 double values, defining first point it.
1765 # @return New GEOM.GEOM_Object, containing the created box.
1766 # @ref tui_creation_box "Example"
1767 def MakeBox(self,x1,y1,z1,x2,y2,z2):
1769 Create a box by coordinates of two opposite vertices.
1772 x1,y1,z1 double values, defining first point.
1773 x2,y2,z2 double values, defining second point.
1776 New GEOM.GEOM_Object, containing the created box.
1778 # Example: see GEOM_TestAll.py
1779 pnt1 = self.MakeVertex(x1,y1,z1)
1780 pnt2 = self.MakeVertex(x2,y2,z2)
1781 return self.MakeBoxTwoPnt(pnt1,pnt2)
1783 ## Create a box with specified dimensions along the coordinate axes
1784 # and with edges, parallel to the coordinate axes.
1785 # Center of the box will be at point (DX/2, DY/2, DZ/2).
1786 # @param theDX Length of Box edges, parallel to OX axis.
1787 # @param theDY Length of Box edges, parallel to OY axis.
1788 # @param theDZ Length of Box edges, parallel to OZ axis.
1789 # @return New GEOM.GEOM_Object, containing the created box.
1791 # @ref tui_creation_box "Example"
1792 def MakeBoxDXDYDZ(self,theDX, theDY, theDZ):
1794 Create a box with specified dimensions along the coordinate axes
1795 and with edges, parallel to the coordinate axes.
1796 Center of the box will be at point (DX/2, DY/2, DZ/2).
1799 theDX Length of Box edges, parallel to OX axis.
1800 theDY Length of Box edges, parallel to OY axis.
1801 theDZ Length of Box edges, parallel to OZ axis.
1804 New GEOM.GEOM_Object, containing the created box.
1806 # Example: see GEOM_TestAll.py
1807 theDX,theDY,theDZ,Parameters = ParseParameters(theDX, theDY, theDZ)
1808 anObj = self.PrimOp.MakeBoxDXDYDZ(theDX, theDY, theDZ)
1809 RaiseIfFailed("MakeBoxDXDYDZ", self.PrimOp)
1810 anObj.SetParameters(Parameters)
1813 ## Create a box with two specified opposite vertices,
1814 # and with edges, parallel to the coordinate axes
1815 # @param thePnt1 First of two opposite vertices.
1816 # @param thePnt2 Second of two opposite vertices.
1817 # @return New GEOM.GEOM_Object, containing the created box.
1819 # @ref tui_creation_box "Example"
1820 def MakeBoxTwoPnt(self,thePnt1, thePnt2):
1822 Create a box with two specified opposite vertices,
1823 and with edges, parallel to the coordinate axes
1826 thePnt1 First of two opposite vertices.
1827 thePnt2 Second of two opposite vertices.
1830 New GEOM.GEOM_Object, containing the created box.
1832 # Example: see GEOM_TestAll.py
1833 anObj = self.PrimOp.MakeBoxTwoPnt(thePnt1, thePnt2)
1834 RaiseIfFailed("MakeBoxTwoPnt", self.PrimOp)
1837 ## Create a face with specified dimensions with edges parallel to coordinate axes.
1838 # @param theH height of Face.
1839 # @param theW width of Face.
1840 # @param theOrientation face orientation: 1-OXY, 2-OYZ, 3-OZX
1841 # @return New GEOM.GEOM_Object, containing the created face.
1843 # @ref tui_creation_face "Example"
1844 def MakeFaceHW(self,theH, theW, theOrientation):
1846 Create a face with specified dimensions with edges parallel to coordinate axes.
1849 theH height of Face.
1851 theOrientation face orientation: 1-OXY, 2-OYZ, 3-OZX
1854 New GEOM.GEOM_Object, containing the created face.
1856 # Example: see GEOM_TestAll.py
1857 theH,theW,Parameters = ParseParameters(theH, theW)
1858 anObj = self.PrimOp.MakeFaceHW(theH, theW, theOrientation)
1859 RaiseIfFailed("MakeFaceHW", self.PrimOp)
1860 anObj.SetParameters(Parameters)
1863 ## Create a face from another plane and two sizes,
1864 # vertical size and horisontal size.
1865 # @param theObj Normale vector to the creating face or
1867 # @param theH Height (vertical size).
1868 # @param theW Width (horisontal size).
1869 # @return New GEOM.GEOM_Object, containing the created face.
1871 # @ref tui_creation_face "Example"
1872 def MakeFaceObjHW(self, theObj, theH, theW):
1874 Create a face from another plane and two sizes,
1875 vertical size and horisontal size.
1878 theObj Normale vector to the creating face or
1880 theH Height (vertical size).
1881 theW Width (horisontal size).
1884 New GEOM_Object, containing the created face.
1886 # Example: see GEOM_TestAll.py
1887 theH,theW,Parameters = ParseParameters(theH, theW)
1888 anObj = self.PrimOp.MakeFaceObjHW(theObj, theH, theW)
1889 RaiseIfFailed("MakeFaceObjHW", self.PrimOp)
1890 anObj.SetParameters(Parameters)
1893 ## Create a disk with given center, normal vector and radius.
1894 # @param thePnt Disk center.
1895 # @param theVec Vector, normal to the plane of the disk.
1896 # @param theR Disk radius.
1897 # @return New GEOM.GEOM_Object, containing the created disk.
1899 # @ref tui_creation_disk "Example"
1900 def MakeDiskPntVecR(self,thePnt, theVec, theR):
1902 Create a disk with given center, normal vector and radius.
1906 theVec Vector, normal to the plane of the disk.
1910 New GEOM.GEOM_Object, containing the created disk.
1912 # Example: see GEOM_TestAll.py
1913 theR,Parameters = ParseParameters(theR)
1914 anObj = self.PrimOp.MakeDiskPntVecR(thePnt, theVec, theR)
1915 RaiseIfFailed("MakeDiskPntVecR", self.PrimOp)
1916 anObj.SetParameters(Parameters)
1919 ## Create a disk, passing through three given points
1920 # @param thePnt1,thePnt2,thePnt3 Points, defining the disk.
1921 # @return New GEOM.GEOM_Object, containing the created disk.
1923 # @ref tui_creation_disk "Example"
1924 def MakeDiskThreePnt(self,thePnt1, thePnt2, thePnt3):
1926 Create a disk, passing through three given points
1929 thePnt1,thePnt2,thePnt3 Points, defining the disk.
1932 New GEOM.GEOM_Object, containing the created disk.
1934 # Example: see GEOM_TestAll.py
1935 anObj = self.PrimOp.MakeDiskThreePnt(thePnt1, thePnt2, thePnt3)
1936 RaiseIfFailed("MakeDiskThreePnt", self.PrimOp)
1939 ## Create a disk with specified dimensions along OX-OY coordinate axes.
1940 # @param theR Radius of Face.
1941 # @param theOrientation set the orientation belong axis OXY or OYZ or OZX
1942 # @return New GEOM.GEOM_Object, containing the created disk.
1944 # @ref tui_creation_face "Example"
1945 def MakeDiskR(self,theR, theOrientation):
1947 Create a disk with specified dimensions along OX-OY coordinate axes.
1950 theR Radius of Face.
1951 theOrientation set the orientation belong axis OXY or OYZ or OZX
1954 New GEOM.GEOM_Object, containing the created disk.
1957 Disk3 = geompy.MakeDiskR(100., 1) #(1 Doubles, 1 Int)->GEOM_Object
1959 # Example: see GEOM_TestAll.py
1960 theR,Parameters = ParseParameters(theR)
1961 anObj = self.PrimOp.MakeDiskR(theR, theOrientation)
1962 RaiseIfFailed("MakeDiskR", self.PrimOp)
1963 anObj.SetParameters(Parameters)
1966 ## Create a cylinder with given base point, axis, radius and height.
1967 # @param thePnt Central point of cylinder base.
1968 # @param theAxis Cylinder axis.
1969 # @param theR Cylinder radius.
1970 # @param theH Cylinder height.
1971 # @return New GEOM.GEOM_Object, containing the created cylinder.
1973 # @ref tui_creation_cylinder "Example"
1974 def MakeCylinder(self,thePnt, theAxis, theR, theH):
1976 Create a cylinder with given base point, axis, radius and height.
1979 thePnt Central point of cylinder base.
1980 theAxis Cylinder axis.
1981 theR Cylinder radius.
1982 theH Cylinder height.
1985 New GEOM.GEOM_Object, containing the created cylinder.
1987 # Example: see GEOM_TestAll.py
1988 theR,theH,Parameters = ParseParameters(theR, theH)
1989 anObj = self.PrimOp.MakeCylinderPntVecRH(thePnt, theAxis, theR, theH)
1990 RaiseIfFailed("MakeCylinderPntVecRH", self.PrimOp)
1991 anObj.SetParameters(Parameters)
1994 ## Create a cylinder with given radius and height at
1995 # the origin of coordinate system. Axis of the cylinder
1996 # will be collinear to the OZ axis of the coordinate system.
1997 # @param theR Cylinder radius.
1998 # @param theH Cylinder height.
1999 # @return New GEOM.GEOM_Object, containing the created cylinder.
2001 # @ref tui_creation_cylinder "Example"
2002 def MakeCylinderRH(self,theR, theH):
2004 Create a cylinder with given radius and height at
2005 the origin of coordinate system. Axis of the cylinder
2006 will be collinear to the OZ axis of the coordinate system.
2009 theR Cylinder radius.
2010 theH Cylinder height.
2013 New GEOM.GEOM_Object, containing the created cylinder.
2015 # Example: see GEOM_TestAll.py
2016 theR,theH,Parameters = ParseParameters(theR, theH)
2017 anObj = self.PrimOp.MakeCylinderRH(theR, theH)
2018 RaiseIfFailed("MakeCylinderRH", self.PrimOp)
2019 anObj.SetParameters(Parameters)
2022 ## Create a sphere with given center and radius.
2023 # @param thePnt Sphere center.
2024 # @param theR Sphere radius.
2025 # @return New GEOM.GEOM_Object, containing the created sphere.
2027 # @ref tui_creation_sphere "Example"
2028 def MakeSpherePntR(self, thePnt, theR):
2030 Create a sphere with given center and radius.
2033 thePnt Sphere center.
2037 New GEOM.GEOM_Object, containing the created sphere.
2039 # Example: see GEOM_TestAll.py
2040 theR,Parameters = ParseParameters(theR)
2041 anObj = self.PrimOp.MakeSpherePntR(thePnt, theR)
2042 RaiseIfFailed("MakeSpherePntR", self.PrimOp)
2043 anObj.SetParameters(Parameters)
2046 ## Create a sphere with given center and radius.
2047 # @param x,y,z Coordinates of sphere center.
2048 # @param theR Sphere radius.
2049 # @return New GEOM.GEOM_Object, containing the created sphere.
2051 # @ref tui_creation_sphere "Example"
2052 def MakeSphere(self, x, y, z, theR):
2054 Create a sphere with given center and radius.
2057 x,y,z Coordinates of sphere center.
2061 New GEOM.GEOM_Object, containing the created sphere.
2063 # Example: see GEOM_TestAll.py
2064 point = self.MakeVertex(x, y, z)
2065 anObj = self.MakeSpherePntR(point, theR)
2068 ## Create a sphere with given radius at the origin of coordinate system.
2069 # @param theR Sphere radius.
2070 # @return New GEOM.GEOM_Object, containing the created sphere.
2072 # @ref tui_creation_sphere "Example"
2073 def MakeSphereR(self, theR):
2075 Create a sphere with given radius at the origin of coordinate system.
2081 New GEOM.GEOM_Object, containing the created sphere.
2083 # Example: see GEOM_TestAll.py
2084 theR,Parameters = ParseParameters(theR)
2085 anObj = self.PrimOp.MakeSphereR(theR)
2086 RaiseIfFailed("MakeSphereR", self.PrimOp)
2087 anObj.SetParameters(Parameters)
2090 ## Create a cone with given base point, axis, height and radiuses.
2091 # @param thePnt Central point of the first cone base.
2092 # @param theAxis Cone axis.
2093 # @param theR1 Radius of the first cone base.
2094 # @param theR2 Radius of the second cone base.
2095 # \note If both radiuses are non-zero, the cone will be truncated.
2096 # \note If the radiuses are equal, a cylinder will be created instead.
2097 # @param theH Cone height.
2098 # @return New GEOM.GEOM_Object, containing the created cone.
2100 # @ref tui_creation_cone "Example"
2101 def MakeCone(self,thePnt, theAxis, theR1, theR2, theH):
2103 Create a cone with given base point, axis, height and radiuses.
2106 thePnt Central point of the first cone base.
2108 theR1 Radius of the first cone base.
2109 theR2 Radius of the second cone base.
2113 If both radiuses are non-zero, the cone will be truncated.
2114 If the radiuses are equal, a cylinder will be created instead.
2117 New GEOM.GEOM_Object, containing the created cone.
2119 # Example: see GEOM_TestAll.py
2120 theR1,theR2,theH,Parameters = ParseParameters(theR1,theR2,theH)
2121 anObj = self.PrimOp.MakeConePntVecR1R2H(thePnt, theAxis, theR1, theR2, theH)
2122 RaiseIfFailed("MakeConePntVecR1R2H", self.PrimOp)
2123 anObj.SetParameters(Parameters)
2126 ## Create a cone with given height and radiuses at
2127 # the origin of coordinate system. Axis of the cone will
2128 # be collinear to the OZ axis of the coordinate system.
2129 # @param theR1 Radius of the first cone base.
2130 # @param theR2 Radius of the second cone base.
2131 # \note If both radiuses are non-zero, the cone will be truncated.
2132 # \note If the radiuses are equal, a cylinder will be created instead.
2133 # @param theH Cone height.
2134 # @return New GEOM.GEOM_Object, containing the created cone.
2136 # @ref tui_creation_cone "Example"
2137 def MakeConeR1R2H(self,theR1, theR2, theH):
2139 Create a cone with given height and radiuses at
2140 the origin of coordinate system. Axis of the cone will
2141 be collinear to the OZ axis of the coordinate system.
2144 theR1 Radius of the first cone base.
2145 theR2 Radius of the second cone base.
2149 If both radiuses are non-zero, the cone will be truncated.
2150 If the radiuses are equal, a cylinder will be created instead.
2153 New GEOM.GEOM_Object, containing the created cone.
2155 # Example: see GEOM_TestAll.py
2156 theR1,theR2,theH,Parameters = ParseParameters(theR1,theR2,theH)
2157 anObj = self.PrimOp.MakeConeR1R2H(theR1, theR2, theH)
2158 RaiseIfFailed("MakeConeR1R2H", self.PrimOp)
2159 anObj.SetParameters(Parameters)
2162 ## Create a torus with given center, normal vector and radiuses.
2163 # @param thePnt Torus central point.
2164 # @param theVec Torus axis of symmetry.
2165 # @param theRMajor Torus major radius.
2166 # @param theRMinor Torus minor radius.
2167 # @return New GEOM.GEOM_Object, containing the created torus.
2169 # @ref tui_creation_torus "Example"
2170 def MakeTorus(self, thePnt, theVec, theRMajor, theRMinor):
2172 Create a torus with given center, normal vector and radiuses.
2175 thePnt Torus central point.
2176 theVec Torus axis of symmetry.
2177 theRMajor Torus major radius.
2178 theRMinor Torus minor radius.
2181 New GEOM.GEOM_Object, containing the created torus.
2183 # Example: see GEOM_TestAll.py
2184 theRMajor,theRMinor,Parameters = ParseParameters(theRMajor,theRMinor)
2185 anObj = self.PrimOp.MakeTorusPntVecRR(thePnt, theVec, theRMajor, theRMinor)
2186 RaiseIfFailed("MakeTorusPntVecRR", self.PrimOp)
2187 anObj.SetParameters(Parameters)
2190 ## Create a torus with given radiuses at the origin of coordinate system.
2191 # @param theRMajor Torus major radius.
2192 # @param theRMinor Torus minor radius.
2193 # @return New GEOM.GEOM_Object, containing the created torus.
2195 # @ref tui_creation_torus "Example"
2196 def MakeTorusRR(self, theRMajor, theRMinor):
2198 Create a torus with given radiuses at the origin of coordinate system.
2201 theRMajor Torus major radius.
2202 theRMinor Torus minor radius.
2205 New GEOM.GEOM_Object, containing the created torus.
2207 # Example: see GEOM_TestAll.py
2208 theRMajor,theRMinor,Parameters = ParseParameters(theRMajor,theRMinor)
2209 anObj = self.PrimOp.MakeTorusRR(theRMajor, theRMinor)
2210 RaiseIfFailed("MakeTorusRR", self.PrimOp)
2211 anObj.SetParameters(Parameters)
2214 # end of l3_3d_primitives
2217 ## @addtogroup l3_complex
2220 ## Create a shape by extrusion of the base shape along a vector, defined by two points.
2221 # @param theBase Base shape to be extruded.
2222 # @param thePoint1 First end of extrusion vector.
2223 # @param thePoint2 Second end of extrusion vector.
2224 # @param theScaleFactor Use it to make prism with scaled second base.
2225 # Nagative value means not scaled second base.
2226 # @return New GEOM.GEOM_Object, containing the created prism.
2228 # @ref tui_creation_prism "Example"
2229 def MakePrism(self, theBase, thePoint1, thePoint2, theScaleFactor = -1.0):
2231 Create a shape by extrusion of the base shape along a vector, defined by two points.
2234 theBase Base shape to be extruded.
2235 thePoint1 First end of extrusion vector.
2236 thePoint2 Second end of extrusion vector.
2237 theScaleFactor Use it to make prism with scaled second base.
2238 Nagative value means not scaled second base.
2241 New GEOM.GEOM_Object, containing the created prism.
2243 # Example: see GEOM_TestAll.py
2246 if theScaleFactor > 0:
2247 theScaleFactor,Parameters = ParseParameters(theScaleFactor)
2248 anObj = self.PrimOp.MakePrismTwoPntWithScaling(theBase, thePoint1, thePoint2, theScaleFactor)
2250 anObj = self.PrimOp.MakePrismTwoPnt(theBase, thePoint1, thePoint2)
2251 RaiseIfFailed("MakePrismTwoPnt", self.PrimOp)
2252 anObj.SetParameters(Parameters)
2255 ## Create a shape by extrusion of the base shape along a
2256 # vector, defined by two points, in 2 Ways (forward/backward).
2257 # @param theBase Base shape to be extruded.
2258 # @param thePoint1 First end of extrusion vector.
2259 # @param thePoint2 Second end of extrusion vector.
2260 # @return New GEOM.GEOM_Object, containing the created prism.
2262 # @ref tui_creation_prism "Example"
2263 def MakePrism2Ways(self, theBase, thePoint1, thePoint2):
2265 Create a shape by extrusion of the base shape along a
2266 vector, defined by two points, in 2 Ways (forward/backward).
2269 theBase Base shape to be extruded.
2270 thePoint1 First end of extrusion vector.
2271 thePoint2 Second end of extrusion vector.
2274 New GEOM.GEOM_Object, containing the created prism.
2276 # Example: see GEOM_TestAll.py
2277 anObj = self.PrimOp.MakePrismTwoPnt2Ways(theBase, thePoint1, thePoint2)
2278 RaiseIfFailed("MakePrismTwoPnt", self.PrimOp)
2281 ## Create a shape by extrusion of the base shape along the vector,
2282 # i.e. all the space, transfixed by the base shape during its translation
2283 # along the vector on the given distance.
2284 # @param theBase Base shape to be extruded.
2285 # @param theVec Direction of extrusion.
2286 # @param theH Prism dimension along theVec.
2287 # @param theScaleFactor Use it to make prism with scaled second base.
2288 # Negative value means not scaled second base.
2289 # @return New GEOM.GEOM_Object, containing the created prism.
2291 # @ref tui_creation_prism "Example"
2292 def MakePrismVecH(self, theBase, theVec, theH, theScaleFactor = -1.0):
2294 Create a shape by extrusion of the base shape along the vector,
2295 i.e. all the space, transfixed by the base shape during its translation
2296 along the vector on the given distance.
2299 theBase Base shape to be extruded.
2300 theVec Direction of extrusion.
2301 theH Prism dimension along theVec.
2302 theScaleFactor Use it to make prism with scaled second base.
2303 Negative value means not scaled second base.
2306 New GEOM.GEOM_Object, containing the created prism.
2308 # Example: see GEOM_TestAll.py
2311 if theScaleFactor > 0:
2312 theH,theScaleFactor,Parameters = ParseParameters(theH,theScaleFactor)
2313 anObj = self.PrimOp.MakePrismVecHWithScaling(theBase, theVec, theH, theScaleFactor)
2315 theH,Parameters = ParseParameters(theH)
2316 anObj = self.PrimOp.MakePrismVecH(theBase, theVec, theH)
2317 RaiseIfFailed("MakePrismVecH", self.PrimOp)
2318 anObj.SetParameters(Parameters)
2321 ## Create a shape by extrusion of the base shape along the vector,
2322 # i.e. all the space, transfixed by the base shape during its translation
2323 # along the vector on the given distance in 2 Ways (forward/backward).
2324 # @param theBase Base shape to be extruded.
2325 # @param theVec Direction of extrusion.
2326 # @param theH Prism dimension along theVec in forward direction.
2327 # @return New GEOM.GEOM_Object, containing the created prism.
2329 # @ref tui_creation_prism "Example"
2330 def MakePrismVecH2Ways(self, theBase, theVec, theH):
2332 Create a shape by extrusion of the base shape along the vector,
2333 i.e. all the space, transfixed by the base shape during its translation
2334 along the vector on the given distance in 2 Ways (forward/backward).
2337 theBase Base shape to be extruded.
2338 theVec Direction of extrusion.
2339 theH Prism dimension along theVec in forward direction.
2342 New GEOM.GEOM_Object, containing the created prism.
2344 # Example: see GEOM_TestAll.py
2345 theH,Parameters = ParseParameters(theH)
2346 anObj = self.PrimOp.MakePrismVecH2Ways(theBase, theVec, theH)
2347 RaiseIfFailed("MakePrismVecH2Ways", self.PrimOp)
2348 anObj.SetParameters(Parameters)
2351 ## Create a shape by extrusion of the base shape along the dx, dy, dz direction
2352 # @param theBase Base shape to be extruded.
2353 # @param theDX, theDY, theDZ Directions of extrusion.
2354 # @param theScaleFactor Use it to make prism with scaled second base.
2355 # Nagative value means not scaled second base.
2356 # @return New GEOM.GEOM_Object, containing the created prism.
2358 # @ref tui_creation_prism "Example"
2359 def MakePrismDXDYDZ(self, theBase, theDX, theDY, theDZ, theScaleFactor = -1.0):
2361 Create a shape by extrusion of the base shape along the dx, dy, dz direction
2364 theBase Base shape to be extruded.
2365 theDX, theDY, theDZ Directions of extrusion.
2366 theScaleFactor Use it to make prism with scaled second base.
2367 Nagative value means not scaled second base.
2370 New GEOM.GEOM_Object, containing the created prism.
2372 # Example: see GEOM_TestAll.py
2375 if theScaleFactor > 0:
2376 theDX,theDY,theDZ,theScaleFactor,Parameters = ParseParameters(theDX, theDY, theDZ, theScaleFactor)
2377 anObj = self.PrimOp.MakePrismDXDYDZWithScaling(theBase, theDX, theDY, theDZ, theScaleFactor)
2379 theDX,theDY,theDZ,Parameters = ParseParameters(theDX, theDY, theDZ)
2380 anObj = self.PrimOp.MakePrismDXDYDZ(theBase, theDX, theDY, theDZ)
2381 RaiseIfFailed("MakePrismDXDYDZ", self.PrimOp)
2382 anObj.SetParameters(Parameters)
2385 ## Create a shape by extrusion of the base shape along the dx, dy, dz direction
2386 # i.e. all the space, transfixed by the base shape during its translation
2387 # along the vector on the given distance in 2 Ways (forward/backward).
2388 # @param theBase Base shape to be extruded.
2389 # @param theDX, theDY, theDZ Directions of extrusion.
2390 # @return New GEOM.GEOM_Object, containing the created prism.
2392 # @ref tui_creation_prism "Example"
2393 def MakePrismDXDYDZ2Ways(self, theBase, theDX, theDY, theDZ):
2395 Create a shape by extrusion of the base shape along the dx, dy, dz direction
2396 i.e. all the space, transfixed by the base shape during its translation
2397 along the vector on the given distance in 2 Ways (forward/backward).
2400 theBase Base shape to be extruded.
2401 theDX, theDY, theDZ Directions of extrusion.
2404 New GEOM.GEOM_Object, containing the created prism.
2406 # Example: see GEOM_TestAll.py
2407 theDX,theDY,theDZ,Parameters = ParseParameters(theDX, theDY, theDZ)
2408 anObj = self.PrimOp.MakePrismDXDYDZ2Ways(theBase, theDX, theDY, theDZ)
2409 RaiseIfFailed("MakePrismDXDYDZ2Ways", self.PrimOp)
2410 anObj.SetParameters(Parameters)
2413 ## Create a shape by revolution of the base shape around the axis
2414 # on the given angle, i.e. all the space, transfixed by the base
2415 # shape during its rotation around the axis on the given angle.
2416 # @param theBase Base shape to be rotated.
2417 # @param theAxis Rotation axis.
2418 # @param theAngle Rotation angle in radians.
2419 # @return New GEOM.GEOM_Object, containing the created revolution.
2421 # @ref tui_creation_revolution "Example"
2422 def MakeRevolution(self, theBase, theAxis, theAngle):
2424 Create a shape by revolution of the base shape around the axis
2425 on the given angle, i.e. all the space, transfixed by the base
2426 shape during its rotation around the axis on the given angle.
2429 theBase Base shape to be rotated.
2430 theAxis Rotation axis.
2431 theAngle Rotation angle in radians.
2434 New GEOM.GEOM_Object, containing the created revolution.
2436 # Example: see GEOM_TestAll.py
2437 theAngle,Parameters = ParseParameters(theAngle)
2438 anObj = self.PrimOp.MakeRevolutionAxisAngle(theBase, theAxis, theAngle)
2439 RaiseIfFailed("MakeRevolutionAxisAngle", self.PrimOp)
2440 anObj.SetParameters(Parameters)
2443 ## Create a shape by revolution of the base shape around the axis
2444 # on the given angle, i.e. all the space, transfixed by the base
2445 # shape during its rotation around the axis on the given angle in
2446 # both directions (forward/backward)
2447 # @param theBase Base shape to be rotated.
2448 # @param theAxis Rotation axis.
2449 # @param theAngle Rotation angle in radians.
2450 # @return New GEOM.GEOM_Object, containing the created revolution.
2452 # @ref tui_creation_revolution "Example"
2453 def MakeRevolution2Ways(self, theBase, theAxis, theAngle):
2455 Create a shape by revolution of the base shape around the axis
2456 on the given angle, i.e. all the space, transfixed by the base
2457 shape during its rotation around the axis on the given angle in
2458 both directions (forward/backward).
2461 theBase Base shape to be rotated.
2462 theAxis Rotation axis.
2463 theAngle Rotation angle in radians.
2466 New GEOM.GEOM_Object, containing the created revolution.
2468 theAngle,Parameters = ParseParameters(theAngle)
2469 anObj = self.PrimOp.MakeRevolutionAxisAngle2Ways(theBase, theAxis, theAngle)
2470 RaiseIfFailed("MakeRevolutionAxisAngle2Ways", self.PrimOp)
2471 anObj.SetParameters(Parameters)
2474 ## Create a filling from the given compound of contours.
2475 # @param theShape the compound of contours
2476 # @param theMinDeg a minimal degree of BSpline surface to create
2477 # @param theMaxDeg a maximal degree of BSpline surface to create
2478 # @param theTol2D a 2d tolerance to be reached
2479 # @param theTol3D a 3d tolerance to be reached
2480 # @param theNbIter a number of iteration of approximation algorithm
2481 # @param theMethod Kind of method to perform filling operation(see GEOM::filling_oper_method())
2482 # @param isApprox if True, BSpline curves are generated in the process
2483 # of surface construction. By default it is False, that means
2484 # the surface is created using given curves. The usage of
2485 # Approximation makes the algorithm work slower, but allows
2486 # building the surface for rather complex cases.
2487 # @return New GEOM.GEOM_Object, containing the created filling surface.
2489 # @ref tui_creation_filling "Example"
2490 def MakeFilling(self, theShape, theMinDeg=2, theMaxDeg=5, theTol2D=0.0001,
2491 theTol3D=0.0001, theNbIter=0, theMethod=GEOM.FOM_Default, isApprox=0):
2493 Create a filling from the given compound of contours.
2496 theShape the compound of contours
2497 theMinDeg a minimal degree of BSpline surface to create
2498 theMaxDeg a maximal degree of BSpline surface to create
2499 theTol2D a 2d tolerance to be reached
2500 theTol3D a 3d tolerance to be reached
2501 theNbIter a number of iteration of approximation algorithm
2502 theMethod Kind of method to perform filling operation(see GEOM::filling_oper_method())
2503 isApprox if True, BSpline curves are generated in the process
2504 of surface construction. By default it is False, that means
2505 the surface is created using given curves. The usage of
2506 Approximation makes the algorithm work slower, but allows
2507 building the surface for rather complex cases
2510 New GEOM.GEOM_Object, containing the created filling surface.
2513 filling = geompy.MakeFilling(compound, 2, 5, 0.0001, 0.0001, 5)
2515 # Example: see GEOM_TestAll.py
2516 theMinDeg,theMaxDeg,theTol2D,theTol3D,theNbIter,Parameters = ParseParameters(theMinDeg, theMaxDeg, theTol2D, theTol3D, theNbIter)
2517 anObj = self.PrimOp.MakeFilling(theShape, theMinDeg, theMaxDeg,
2518 theTol2D, theTol3D, theNbIter,
2519 theMethod, isApprox)
2520 RaiseIfFailed("MakeFilling", self.PrimOp)
2521 anObj.SetParameters(Parameters)
2525 ## Create a filling from the given compound of contours.
2526 # This method corresponds to MakeFilling with isApprox=True
2527 # @param theShape the compound of contours
2528 # @param theMinDeg a minimal degree of BSpline surface to create
2529 # @param theMaxDeg a maximal degree of BSpline surface to create
2530 # @param theTol3D a 3d tolerance to be reached
2531 # @return New GEOM.GEOM_Object, containing the created filling surface.
2533 # @ref tui_creation_filling "Example"
2534 def MakeFillingNew(self, theShape, theMinDeg=2, theMaxDeg=5, theTol3D=0.0001):
2536 Create a filling from the given compound of contours.
2537 This method corresponds to MakeFilling with isApprox=True
2540 theShape the compound of contours
2541 theMinDeg a minimal degree of BSpline surface to create
2542 theMaxDeg a maximal degree of BSpline surface to create
2543 theTol3D a 3d tolerance to be reached
2546 New GEOM.GEOM_Object, containing the created filling surface.
2549 filling = geompy.MakeFillingNew(compound, 2, 5, 0.0001)
2551 # Example: see GEOM_TestAll.py
2552 theMinDeg,theMaxDeg,theTol3D,Parameters = ParseParameters(theMinDeg, theMaxDeg, theTol3D)
2553 anObj = self.PrimOp.MakeFilling(theShape, theMinDeg, theMaxDeg,
2554 0, theTol3D, 0, GEOM.FOM_Default, True)
2555 RaiseIfFailed("MakeFillingNew", self.PrimOp)
2556 anObj.SetParameters(Parameters)
2559 ## Create a shell or solid passing through set of sections.Sections should be wires,edges or vertices.
2560 # @param theSeqSections - set of specified sections.
2561 # @param theModeSolid - mode defining building solid or shell
2562 # @param thePreci - precision 3D used for smoothing
2563 # @param theRuled - mode defining type of the result surfaces (ruled or smoothed).
2564 # @return New GEOM.GEOM_Object, containing the created shell or solid.
2566 # @ref swig_todo "Example"
2567 def MakeThruSections(self,theSeqSections,theModeSolid,thePreci,theRuled):
2569 Create a shell or solid passing through set of sections.Sections should be wires,edges or vertices.
2572 theSeqSections - set of specified sections.
2573 theModeSolid - mode defining building solid or shell
2574 thePreci - precision 3D used for smoothing
2575 theRuled - mode defining type of the result surfaces (ruled or smoothed).
2578 New GEOM.GEOM_Object, containing the created shell or solid.
2580 # Example: see GEOM_TestAll.py
2581 anObj = self.PrimOp.MakeThruSections(theSeqSections,theModeSolid,thePreci,theRuled)
2582 RaiseIfFailed("MakeThruSections", self.PrimOp)
2585 ## Create a shape by extrusion of the base shape along
2586 # the path shape. The path shape can be a wire or an edge.
2587 # @param theBase Base shape to be extruded.
2588 # @param thePath Path shape to extrude the base shape along it.
2589 # @return New GEOM.GEOM_Object, containing the created pipe.
2591 # @ref tui_creation_pipe "Example"
2592 def MakePipe(self,theBase, thePath):
2594 Create a shape by extrusion of the base shape along
2595 the path shape. The path shape can be a wire or an edge.
2598 theBase Base shape to be extruded.
2599 thePath Path shape to extrude the base shape along it.
2602 New GEOM.GEOM_Object, containing the created pipe.
2604 # Example: see GEOM_TestAll.py
2605 anObj = self.PrimOp.MakePipe(theBase, thePath)
2606 RaiseIfFailed("MakePipe", self.PrimOp)
2609 ## Create a shape by extrusion of the profile shape along
2610 # the path shape. The path shape can be a wire or an edge.
2611 # the several profiles can be specified in the several locations of path.
2612 # @param theSeqBases - list of Bases shape to be extruded.
2613 # @param theLocations - list of locations on the path corresponding
2614 # specified list of the Bases shapes. Number of locations
2615 # should be equal to number of bases or list of locations can be empty.
2616 # @param thePath - Path shape to extrude the base shape along it.
2617 # @param theWithContact - the mode defining that the section is translated to be in
2618 # contact with the spine.
2619 # @param theWithCorrection - defining that the section is rotated to be
2620 # orthogonal to the spine tangent in the correspondent point
2621 # @return New GEOM.GEOM_Object, containing the created pipe.
2623 # @ref tui_creation_pipe_with_diff_sec "Example"
2624 def MakePipeWithDifferentSections(self, theSeqBases,
2625 theLocations, thePath,
2626 theWithContact, theWithCorrection):
2628 Create a shape by extrusion of the profile shape along
2629 the path shape. The path shape can be a wire or an edge.
2630 the several profiles can be specified in the several locations of path.
2633 theSeqBases - list of Bases shape to be extruded.
2634 theLocations - list of locations on the path corresponding
2635 specified list of the Bases shapes. Number of locations
2636 should be equal to number of bases or list of locations can be empty.
2637 thePath - Path shape to extrude the base shape along it.
2638 theWithContact - the mode defining that the section is translated to be in
2639 contact with the spine(0/1)
2640 theWithCorrection - defining that the section is rotated to be
2641 orthogonal to the spine tangent in the correspondent point (0/1)
2644 New GEOM.GEOM_Object, containing the created pipe.
2646 anObj = self.PrimOp.MakePipeWithDifferentSections(theSeqBases,
2647 theLocations, thePath,
2648 theWithContact, theWithCorrection)
2649 RaiseIfFailed("MakePipeWithDifferentSections", self.PrimOp)
2652 ## Create a shape by extrusion of the profile shape along
2653 # the path shape. The path shape can be a wire or a edge.
2654 # the several profiles can be specified in the several locations of path.
2655 # @param theSeqBases - list of Bases shape to be extruded. Base shape must be
2656 # shell or face. If number of faces in neighbour sections
2657 # aren't coincided result solid between such sections will
2658 # be created using external boundaries of this shells.
2659 # @param theSeqSubBases - list of corresponding sub-shapes of section shapes.
2660 # This list is used for searching correspondences between
2661 # faces in the sections. Size of this list must be equal
2662 # to size of list of base shapes.
2663 # @param theLocations - list of locations on the path corresponding
2664 # specified list of the Bases shapes. Number of locations
2665 # should be equal to number of bases. First and last
2666 # locations must be coincided with first and last vertexes
2667 # of path correspondingly.
2668 # @param thePath - Path shape to extrude the base shape along it.
2669 # @param theWithContact - the mode defining that the section is translated to be in
2670 # contact with the spine.
2671 # @param theWithCorrection - defining that the section is rotated to be
2672 # orthogonal to the spine tangent in the correspondent point
2673 # @return New GEOM.GEOM_Object, containing the created solids.
2675 # @ref tui_creation_pipe_with_shell_sec "Example"
2676 def MakePipeWithShellSections(self,theSeqBases, theSeqSubBases,
2677 theLocations, thePath,
2678 theWithContact, theWithCorrection):
2680 Create a shape by extrusion of the profile shape along
2681 the path shape. The path shape can be a wire or a edge.
2682 the several profiles can be specified in the several locations of path.
2685 theSeqBases - list of Bases shape to be extruded. Base shape must be
2686 shell or face. If number of faces in neighbour sections
2687 aren't coincided result solid between such sections will
2688 be created using external boundaries of this shells.
2689 theSeqSubBases - list of corresponding sub-shapes of section shapes.
2690 This list is used for searching correspondences between
2691 faces in the sections. Size of this list must be equal
2692 to size of list of base shapes.
2693 theLocations - list of locations on the path corresponding
2694 specified list of the Bases shapes. Number of locations
2695 should be equal to number of bases. First and last
2696 locations must be coincided with first and last vertexes
2697 of path correspondingly.
2698 thePath - Path shape to extrude the base shape along it.
2699 theWithContact - the mode defining that the section is translated to be in
2700 contact with the spine (0/1)
2701 theWithCorrection - defining that the section is rotated to be
2702 orthogonal to the spine tangent in the correspondent point (0/1)
2705 New GEOM.GEOM_Object, containing the created solids.
2707 anObj = self.PrimOp.MakePipeWithShellSections(theSeqBases, theSeqSubBases,
2708 theLocations, thePath,
2709 theWithContact, theWithCorrection)
2710 RaiseIfFailed("MakePipeWithShellSections", self.PrimOp)
2713 ## Create a shape by extrusion of the profile shape along
2714 # the path shape. This function is used only for debug pipe
2715 # functionality - it is a version of function MakePipeWithShellSections()
2716 # which give a possibility to recieve information about
2717 # creating pipe between each pair of sections step by step.
2718 def MakePipeWithShellSectionsBySteps(self, theSeqBases, theSeqSubBases,
2719 theLocations, thePath,
2720 theWithContact, theWithCorrection):
2722 Create a shape by extrusion of the profile shape along
2723 the path shape. This function is used only for debug pipe
2724 functionality - it is a version of previous function
2725 geompy.MakePipeWithShellSections() which give a possibility to
2726 recieve information about creating pipe between each pair of
2727 sections step by step.
2730 nbsect = len(theSeqBases)
2731 nbsubsect = len(theSeqSubBases)
2732 #print "nbsect = ",nbsect
2733 for i in range(1,nbsect):
2735 tmpSeqBases = [ theSeqBases[i-1], theSeqBases[i] ]
2736 tmpLocations = [ theLocations[i-1], theLocations[i] ]
2738 if nbsubsect>0: tmpSeqSubBases = [ theSeqSubBases[i-1], theSeqSubBases[i] ]
2739 anObj = self.PrimOp.MakePipeWithShellSections(tmpSeqBases, tmpSeqSubBases,
2740 tmpLocations, thePath,
2741 theWithContact, theWithCorrection)
2742 if self.PrimOp.IsDone() == 0:
2743 print "Problems with pipe creation between ",i," and ",i+1," sections"
2744 RaiseIfFailed("MakePipeWithShellSections", self.PrimOp)
2747 print "Pipe between ",i," and ",i+1," sections is OK"
2752 resc = self.MakeCompound(res)
2753 #resc = self.MakeSewing(res, 0.001)
2754 #print "resc: ",resc
2757 ## Create solids between given sections
2758 # @param theSeqBases - list of sections (shell or face).
2759 # @param theLocations - list of corresponding vertexes
2760 # @return New GEOM.GEOM_Object, containing the created solids.
2762 # @ref tui_creation_pipe_without_path "Example"
2763 def MakePipeShellsWithoutPath(self, theSeqBases, theLocations):
2765 Create solids between given sections
2768 theSeqBases - list of sections (shell or face).
2769 theLocations - list of corresponding vertexes
2772 New GEOM.GEOM_Object, containing the created solids.
2774 anObj = self.PrimOp.MakePipeShellsWithoutPath(theSeqBases, theLocations)
2775 RaiseIfFailed("MakePipeShellsWithoutPath", self.PrimOp)
2778 ## Create a shape by extrusion of the base shape along
2779 # the path shape with constant bi-normal direction along the given vector.
2780 # The path shape can be a wire or an edge.
2781 # @param theBase Base shape to be extruded.
2782 # @param thePath Path shape to extrude the base shape along it.
2783 # @param theVec Vector defines a constant binormal direction to keep the
2784 # same angle beetween the direction and the sections
2785 # along the sweep surface.
2786 # @return New GEOM.GEOM_Object, containing the created pipe.
2788 # @ref tui_creation_pipe "Example"
2789 def MakePipeBiNormalAlongVector(self,theBase, thePath, theVec):
2791 Create a shape by extrusion of the base shape along
2792 the path shape with constant bi-normal direction along the given vector.
2793 The path shape can be a wire or an edge.
2796 theBase Base shape to be extruded.
2797 thePath Path shape to extrude the base shape along it.
2798 theVec Vector defines a constant binormal direction to keep the
2799 same angle beetween the direction and the sections
2800 along the sweep surface.
2803 New GEOM.GEOM_Object, containing the created pipe.
2805 # Example: see GEOM_TestAll.py
2806 anObj = self.PrimOp.MakePipeBiNormalAlongVector(theBase, thePath, theVec)
2807 RaiseIfFailed("MakePipeBiNormalAlongVector", self.PrimOp)
2813 ## @addtogroup l3_advanced
2816 ## Create a linear edge with specified ends.
2817 # @param thePnt1 Point for the first end of edge.
2818 # @param thePnt2 Point for the second end of edge.
2819 # @return New GEOM.GEOM_Object, containing the created edge.
2821 # @ref tui_creation_edge "Example"
2822 def MakeEdge(self,thePnt1, thePnt2):
2824 Create a linear edge with specified ends.
2827 thePnt1 Point for the first end of edge.
2828 thePnt2 Point for the second end of edge.
2831 New GEOM.GEOM_Object, containing the created edge.
2833 # Example: see GEOM_TestAll.py
2834 anObj = self.ShapesOp.MakeEdge(thePnt1, thePnt2)
2835 RaiseIfFailed("MakeEdge", self.ShapesOp)
2838 ## Create a new edge, corresponding to the given length on the given curve.
2839 # @param theRefCurve The referenced curve (edge).
2840 # @param theLength Length on the referenced curve. It can be negative.
2841 # @param theStartPoint Any point can be selected for it, the new edge will begin
2842 # at the end of \a theRefCurve, close to the selected point.
2843 # If None, start from the first point of \a theRefCurve.
2844 # @return New GEOM.GEOM_Object, containing the created edge.
2846 # @ref tui_creation_edge "Example"
2847 def MakeEdgeOnCurveByLength(self, theRefCurve, theLength, theStartPoint = None):
2849 Create a new edge, corresponding to the given length on the given curve.
2852 theRefCurve The referenced curve (edge).
2853 theLength Length on the referenced curve. It can be negative.
2854 theStartPoint Any point can be selected for it, the new edge will begin
2855 at the end of theRefCurve, close to the selected point.
2856 If None, start from the first point of theRefCurve.
2859 New GEOM.GEOM_Object, containing the created edge.
2861 # Example: see GEOM_TestAll.py
2862 theLength, Parameters = ParseParameters(theLength)
2863 anObj = self.ShapesOp.MakeEdgeOnCurveByLength(theRefCurve, theLength, theStartPoint)
2864 RaiseIfFailed("MakeEdgeOnCurveByLength", self.ShapesOp)
2865 anObj.SetParameters(Parameters)
2868 ## Create an edge from specified wire.
2869 # @param theWire source Wire
2870 # @param theLinearTolerance linear tolerance value (default = 1e-07)
2871 # @param theAngularTolerance angular tolerance value (default = 1e-12)
2872 # @return New GEOM.GEOM_Object, containing the created edge.
2874 # @ref tui_creation_edge "Example"
2875 def MakeEdgeWire(self, theWire, theLinearTolerance = 1e-07, theAngularTolerance = 1e-12):
2877 Create an edge from specified wire.
2881 theLinearTolerance linear tolerance value (default = 1e-07)
2882 theAngularTolerance angular tolerance value (default = 1e-12)
2885 New GEOM.GEOM_Object, containing the created edge.
2887 # Example: see GEOM_TestAll.py
2888 anObj = self.ShapesOp.MakeEdgeWire(theWire, theLinearTolerance, theAngularTolerance)
2889 RaiseIfFailed("MakeEdgeWire", self.ShapesOp)
2892 ## Create a wire from the set of edges and wires.
2893 # @param theEdgesAndWires List of edges and/or wires.
2894 # @param theTolerance Maximum distance between vertices, that will be merged.
2895 # Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion())
2896 # @return New GEOM.GEOM_Object, containing the created wire.
2898 # @ref tui_creation_wire "Example"
2899 def MakeWire(self, theEdgesAndWires, theTolerance = 1e-07):
2901 Create a wire from the set of edges and wires.
2904 theEdgesAndWires List of edges and/or wires.
2905 theTolerance Maximum distance between vertices, that will be merged.
2906 Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion()).
2909 New GEOM.GEOM_Object, containing the created wire.
2911 # Example: see GEOM_TestAll.py
2912 anObj = self.ShapesOp.MakeWire(theEdgesAndWires, theTolerance)
2913 RaiseIfFailed("MakeWire", self.ShapesOp)
2916 ## Create a face on the given wire.
2917 # @param theWire closed Wire or Edge to build the face on.
2918 # @param isPlanarWanted If TRUE, the algorithm tries to build a planar face.
2919 # If the tolerance of the obtained planar face is less
2920 # than 1e-06, this face will be returned, otherwise the
2921 # algorithm tries to build any suitable face on the given
2922 # wire and prints a warning message.
2923 # @return New GEOM.GEOM_Object, containing the created face.
2925 # @ref tui_creation_face "Example"
2926 def MakeFace(self, theWire, isPlanarWanted):
2928 Create a face on the given wire.
2931 theWire closed Wire or Edge to build the face on.
2932 isPlanarWanted If TRUE, the algorithm tries to build a planar face.
2933 If the tolerance of the obtained planar face is less
2934 than 1e-06, this face will be returned, otherwise the
2935 algorithm tries to build any suitable face on the given
2936 wire and prints a warning message.
2939 New GEOM.GEOM_Object, containing the created face.
2941 # Example: see GEOM_TestAll.py
2942 anObj = self.ShapesOp.MakeFace(theWire, isPlanarWanted)
2943 if isPlanarWanted and anObj is not None and self.ShapesOp.GetErrorCode() == "MAKE_FACE_TOLERANCE_TOO_BIG":
2944 print "WARNING: Cannot build a planar face: required tolerance is too big. Non-planar face is built."
2946 RaiseIfFailed("MakeFace", self.ShapesOp)
2949 ## Create a face on the given wires set.
2950 # @param theWires List of closed wires or edges to build the face on.
2951 # @param isPlanarWanted If TRUE, the algorithm tries to build a planar face.
2952 # If the tolerance of the obtained planar face is less
2953 # than 1e-06, this face will be returned, otherwise the
2954 # algorithm tries to build any suitable face on the given
2955 # wire and prints a warning message.
2956 # @return New GEOM.GEOM_Object, containing the created face.
2958 # @ref tui_creation_face "Example"
2959 def MakeFaceWires(self, theWires, isPlanarWanted):
2961 Create a face on the given wires set.
2964 theWires List of closed wires or edges to build the face on.
2965 isPlanarWanted If TRUE, the algorithm tries to build a planar face.
2966 If the tolerance of the obtained planar face is less
2967 than 1e-06, this face will be returned, otherwise the
2968 algorithm tries to build any suitable face on the given
2969 wire and prints a warning message.
2972 New GEOM.GEOM_Object, containing the created face.
2974 # Example: see GEOM_TestAll.py
2975 anObj = self.ShapesOp.MakeFaceWires(theWires, isPlanarWanted)
2976 if isPlanarWanted and anObj is not None and self.ShapesOp.GetErrorCode() == "MAKE_FACE_TOLERANCE_TOO_BIG":
2977 print "WARNING: Cannot build a planar face: required tolerance is too big. Non-planar face is built."
2979 RaiseIfFailed("MakeFaceWires", self.ShapesOp)
2982 ## See MakeFaceWires() method for details.
2984 # @ref tui_creation_face "Example 1"
2985 # \n @ref swig_MakeFaces "Example 2"
2986 def MakeFaces(self, theWires, isPlanarWanted):
2988 See geompy.MakeFaceWires() method for details.
2990 # Example: see GEOM_TestOthers.py
2991 anObj = self.MakeFaceWires(theWires, isPlanarWanted)
2994 ## Create a shell from the set of faces and shells.
2995 # @param theFacesAndShells List of faces and/or shells.
2996 # @return New GEOM.GEOM_Object, containing the created shell.
2998 # @ref tui_creation_shell "Example"
2999 def MakeShell(self,theFacesAndShells):
3001 Create a shell from the set of faces and shells.
3004 theFacesAndShells List of faces and/or shells.
3007 New GEOM.GEOM_Object, containing the created shell.
3009 # Example: see GEOM_TestAll.py
3010 anObj = self.ShapesOp.MakeShell(theFacesAndShells)
3011 RaiseIfFailed("MakeShell", self.ShapesOp)
3014 ## Create a solid, bounded by the given shells.
3015 # @param theShells Sequence of bounding shells.
3016 # @return New GEOM.GEOM_Object, containing the created solid.
3018 # @ref tui_creation_solid "Example"
3019 def MakeSolid(self, theShells):
3021 Create a solid, bounded by the given shells.
3024 theShells Sequence of bounding shells.
3027 New GEOM.GEOM_Object, containing the created solid.
3029 # Example: see GEOM_TestAll.py
3030 if len(theShells) == 1:
3031 descr = self.MeasuOp.IsGoodForSolid(theShells[0])
3033 # raise RuntimeError, "MakeSolidShells : " + descr
3034 if descr == "WRN_SHAPE_UNCLOSED":
3035 raise RuntimeError, "MakeSolidShells : Unable to create solid from unclosed shape"
3036 anObj = self.ShapesOp.MakeSolidShells(theShells)
3037 RaiseIfFailed("MakeSolidShells", self.ShapesOp)
3040 ## Create a compound of the given shapes.
3041 # @param theShapes List of shapes to put in compound.
3042 # @return New GEOM.GEOM_Object, containing the created compound.
3044 # @ref tui_creation_compound "Example"
3045 def MakeCompound(self,theShapes):
3047 Create a compound of the given shapes.
3050 theShapes List of shapes to put in compound.
3053 New GEOM.GEOM_Object, containing the created compound.
3055 # Example: see GEOM_TestAll.py
3056 anObj = self.ShapesOp.MakeCompound(theShapes)
3057 RaiseIfFailed("MakeCompound", self.ShapesOp)
3060 # end of l3_advanced
3063 ## @addtogroup l2_measure
3066 ## Gives quantity of faces in the given shape.
3067 # @param theShape Shape to count faces of.
3068 # @return Quantity of faces.
3070 # @ref swig_NumberOf "Example"
3071 def NumberOfFaces(self, theShape):
3073 Gives quantity of faces in the given shape.
3076 theShape Shape to count faces of.
3081 # Example: see GEOM_TestOthers.py
3082 nb_faces = self.ShapesOp.NumberOfFaces(theShape)
3083 RaiseIfFailed("NumberOfFaces", self.ShapesOp)
3086 ## Gives quantity of edges in the given shape.
3087 # @param theShape Shape to count edges of.
3088 # @return Quantity of edges.
3090 # @ref swig_NumberOf "Example"
3091 def NumberOfEdges(self, theShape):
3093 Gives quantity of edges in the given shape.
3096 theShape Shape to count edges of.
3101 # Example: see GEOM_TestOthers.py
3102 nb_edges = self.ShapesOp.NumberOfEdges(theShape)
3103 RaiseIfFailed("NumberOfEdges", self.ShapesOp)
3106 ## Gives quantity of sub-shapes of type theShapeType in the given shape.
3107 # @param theShape Shape to count sub-shapes of.
3108 # @param theShapeType Type of sub-shapes to count (see ShapeType())
3109 # @return Quantity of sub-shapes of given type.
3111 # @ref swig_NumberOf "Example"
3112 def NumberOfSubShapes(self, theShape, theShapeType):
3114 Gives quantity of sub-shapes of type theShapeType in the given shape.
3117 theShape Shape to count sub-shapes of.
3118 theShapeType Type of sub-shapes to count (see geompy.ShapeType)
3121 Quantity of sub-shapes of given type.
3123 # Example: see GEOM_TestOthers.py
3124 nb_ss = self.ShapesOp.NumberOfSubShapes(theShape, theShapeType)
3125 RaiseIfFailed("NumberOfSubShapes", self.ShapesOp)
3128 ## Gives quantity of solids in the given shape.
3129 # @param theShape Shape to count solids in.
3130 # @return Quantity of solids.
3132 # @ref swig_NumberOf "Example"
3133 def NumberOfSolids(self, theShape):
3135 Gives quantity of solids in the given shape.
3138 theShape Shape to count solids in.
3143 # Example: see GEOM_TestOthers.py
3144 nb_solids = self.ShapesOp.NumberOfSubShapes(theShape, ShapeType["SOLID"])
3145 RaiseIfFailed("NumberOfSolids", self.ShapesOp)
3151 ## @addtogroup l3_healing
3154 ## Reverses an orientation the given shape.
3155 # @param theShape Shape to be reversed.
3156 # @return The reversed copy of theShape.
3158 # @ref swig_ChangeOrientation "Example"
3159 def ChangeOrientation(self,theShape):
3161 Reverses an orientation the given shape.
3164 theShape Shape to be reversed.
3167 The reversed copy of theShape.
3169 # Example: see GEOM_TestAll.py
3170 anObj = self.ShapesOp.ChangeOrientation(theShape)
3171 RaiseIfFailed("ChangeOrientation", self.ShapesOp)
3174 ## See ChangeOrientation() method for details.
3176 # @ref swig_OrientationChange "Example"
3177 def OrientationChange(self,theShape):
3179 See geompy.ChangeOrientation method for details.
3181 # Example: see GEOM_TestOthers.py
3182 anObj = self.ChangeOrientation(theShape)
3188 ## @addtogroup l4_obtain
3191 ## Retrieve all free faces from the given shape.
3192 # Free face is a face, which is not shared between two shells of the shape.
3193 # @param theShape Shape to find free faces in.
3194 # @return List of IDs of all free faces, contained in theShape.
3196 # @ref tui_measurement_tools_page "Example"
3197 def GetFreeFacesIDs(self,theShape):
3199 Retrieve all free faces from the given shape.
3200 Free face is a face, which is not shared between two shells of the shape.
3203 theShape Shape to find free faces in.
3206 List of IDs of all free faces, contained in theShape.
3208 # Example: see GEOM_TestOthers.py
3209 anIDs = self.ShapesOp.GetFreeFacesIDs(theShape)
3210 RaiseIfFailed("GetFreeFacesIDs", self.ShapesOp)
3213 ## Get all sub-shapes of theShape1 of the given type, shared with theShape2.
3214 # @param theShape1 Shape to find sub-shapes in.
3215 # @param theShape2 Shape to find shared sub-shapes with.
3216 # @param theShapeType Type of sub-shapes to be retrieved.
3217 # @return List of sub-shapes of theShape1, shared with theShape2.
3219 # @ref swig_GetSharedShapes "Example"
3220 def GetSharedShapes(self,theShape1, theShape2, theShapeType):
3222 Get all sub-shapes of theShape1 of the given type, shared with theShape2.
3225 theShape1 Shape to find sub-shapes in.
3226 theShape2 Shape to find shared sub-shapes with.
3227 theShapeType Type of sub-shapes to be retrieved.
3230 List of sub-shapes of theShape1, shared with theShape2.
3232 # Example: see GEOM_TestOthers.py
3233 aList = self.ShapesOp.GetSharedShapes(theShape1, theShape2, theShapeType)
3234 RaiseIfFailed("GetSharedShapes", self.ShapesOp)
3237 ## Get all sub-shapes, shared by all shapes in the list <VAR>theShapes</VAR>.
3238 # @param theShapes Shapes to find common sub-shapes of.
3239 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3240 # @return List of objects, that are sub-shapes of all given shapes.
3242 # @ref swig_GetSharedShapes "Example"
3243 def GetSharedShapesMulti(self, theShapes, theShapeType):
3245 Get all sub-shapes, shared by all shapes in the list theShapes.
3248 theShapes Shapes to find common sub-shapes of.
3249 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3252 List of GEOM.GEOM_Object, that are sub-shapes of all given shapes.
3254 # Example: see GEOM_TestOthers.py
3255 aList = self.ShapesOp.GetSharedShapesMulti(theShapes, theShapeType)
3256 RaiseIfFailed("GetSharedShapesMulti", self.ShapesOp)
3259 ## Find in <VAR>theShape</VAR> all sub-shapes of type <VAR>theShapeType</VAR>,
3260 # situated relatively the specified plane by the certain way,
3261 # defined through <VAR>theState</VAR> parameter.
3262 # @param theShape Shape to find sub-shapes of.
3263 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3264 # @param theAx1 Vector (or line, or linear edge), specifying normal
3265 # direction and location of the plane to find shapes on.
3266 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3267 # @return List of all found sub-shapes.
3269 # @ref swig_GetShapesOnPlane "Example"
3270 def GetShapesOnPlane(self,theShape, theShapeType, theAx1, theState):
3272 Find in theShape all sub-shapes of type theShapeType,
3273 situated relatively the specified plane by the certain way,
3274 defined through theState parameter.
3277 theShape Shape to find sub-shapes of.
3278 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3279 theAx1 Vector (or line, or linear edge), specifying normal
3280 direction and location of the plane to find shapes on.
3281 theState The state of the sub-shapes to find (see GEOM::shape_state)
3284 List of all found sub-shapes.
3286 # Example: see GEOM_TestOthers.py
3287 aList = self.ShapesOp.GetShapesOnPlane(theShape, theShapeType, theAx1, theState)
3288 RaiseIfFailed("GetShapesOnPlane", self.ShapesOp)
3291 ## Find in <VAR>theShape</VAR> all sub-shapes of type <VAR>theShapeType</VAR>,
3292 # situated relatively the specified plane by the certain way,
3293 # defined through <VAR>theState</VAR> parameter.
3294 # @param theShape Shape to find sub-shapes of.
3295 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3296 # @param theAx1 Vector (or line, or linear edge), specifying normal
3297 # direction and location of the plane to find shapes on.
3298 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3299 # @return List of all found sub-shapes indices.
3301 # @ref swig_GetShapesOnPlaneIDs "Example"
3302 def GetShapesOnPlaneIDs(self,theShape, theShapeType, theAx1, theState):
3304 Find in theShape all sub-shapes of type theShapeType,
3305 situated relatively the specified plane by the certain way,
3306 defined through theState parameter.
3309 theShape Shape to find sub-shapes of.
3310 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3311 theAx1 Vector (or line, or linear edge), specifying normal
3312 direction and location of the plane to find shapes on.
3313 theState The state of the sub-shapes to find (see GEOM::shape_state)
3316 List of all found sub-shapes indices.
3318 # Example: see GEOM_TestOthers.py
3319 aList = self.ShapesOp.GetShapesOnPlaneIDs(theShape, theShapeType, theAx1, theState)
3320 RaiseIfFailed("GetShapesOnPlaneIDs", self.ShapesOp)
3323 ## Find in <VAR>theShape</VAR> all sub-shapes of type <VAR>theShapeType</VAR>,
3324 # situated relatively the specified plane by the certain way,
3325 # defined through <VAR>theState</VAR> parameter.
3326 # @param theShape Shape to find sub-shapes of.
3327 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3328 # @param theAx1 Vector (or line, or linear edge), specifying normal
3329 # direction of the plane to find shapes on.
3330 # @param thePnt Point specifying location of the plane to find shapes on.
3331 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3332 # @return List of all found sub-shapes.
3334 # @ref swig_GetShapesOnPlaneWithLocation "Example"
3335 def GetShapesOnPlaneWithLocation(self, theShape, theShapeType, theAx1, thePnt, theState):
3337 Find in theShape all sub-shapes of type theShapeType,
3338 situated relatively the specified plane by the certain way,
3339 defined through theState parameter.
3342 theShape Shape to find sub-shapes of.
3343 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3344 theAx1 Vector (or line, or linear edge), specifying normal
3345 direction and location of the plane to find shapes on.
3346 thePnt Point specifying location of the plane to find shapes on.
3347 theState The state of the sub-shapes to find (see GEOM::shape_state)
3350 List of all found sub-shapes.
3352 # Example: see GEOM_TestOthers.py
3353 aList = self.ShapesOp.GetShapesOnPlaneWithLocation(theShape, theShapeType,
3354 theAx1, thePnt, theState)
3355 RaiseIfFailed("GetShapesOnPlaneWithLocation", self.ShapesOp)
3358 ## Find in <VAR>theShape</VAR> all sub-shapes of type <VAR>theShapeType</VAR>,
3359 # situated relatively the specified plane by the certain way,
3360 # defined through <VAR>theState</VAR> parameter.
3361 # @param theShape Shape to find sub-shapes of.
3362 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3363 # @param theAx1 Vector (or line, or linear edge), specifying normal
3364 # direction of the plane to find shapes on.
3365 # @param thePnt Point specifying location of the plane to find shapes on.
3366 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3367 # @return List of all found sub-shapes indices.
3369 # @ref swig_GetShapesOnPlaneWithLocationIDs "Example"
3370 def GetShapesOnPlaneWithLocationIDs(self, theShape, theShapeType, theAx1, thePnt, theState):
3372 Find in theShape all sub-shapes of type theShapeType,
3373 situated relatively the specified plane by the certain way,
3374 defined through theState parameter.
3377 theShape Shape to find sub-shapes of.
3378 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3379 theAx1 Vector (or line, or linear edge), specifying normal
3380 direction and location of the plane to find shapes on.
3381 thePnt Point specifying location of the plane to find shapes on.
3382 theState The state of the sub-shapes to find (see GEOM::shape_state)
3385 List of all found sub-shapes indices.
3387 # Example: see GEOM_TestOthers.py
3388 aList = self.ShapesOp.GetShapesOnPlaneWithLocationIDs(theShape, theShapeType,
3389 theAx1, thePnt, theState)
3390 RaiseIfFailed("GetShapesOnPlaneWithLocationIDs", self.ShapesOp)
3393 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3394 # the specified cylinder by the certain way, defined through \a theState parameter.
3395 # @param theShape Shape to find sub-shapes of.
3396 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3397 # @param theAxis Vector (or line, or linear edge), specifying
3398 # axis of the cylinder to find shapes on.
3399 # @param theRadius Radius of the cylinder to find shapes on.
3400 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3401 # @return List of all found sub-shapes.
3403 # @ref swig_GetShapesOnCylinder "Example"
3404 def GetShapesOnCylinder(self, theShape, theShapeType, theAxis, theRadius, theState):
3406 Find in theShape all sub-shapes of type theShapeType, situated relatively
3407 the specified cylinder by the certain way, defined through theState parameter.
3410 theShape Shape to find sub-shapes of.
3411 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3412 theAxis Vector (or line, or linear edge), specifying
3413 axis of the cylinder to find shapes on.
3414 theRadius Radius of the cylinder to find shapes on.
3415 theState The state of the sub-shapes to find (see GEOM::shape_state)
3418 List of all found sub-shapes.
3420 # Example: see GEOM_TestOthers.py
3421 aList = self.ShapesOp.GetShapesOnCylinder(theShape, theShapeType, theAxis, theRadius, theState)
3422 RaiseIfFailed("GetShapesOnCylinder", self.ShapesOp)
3425 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3426 # the specified cylinder by the certain way, defined through \a theState parameter.
3427 # @param theShape Shape to find sub-shapes of.
3428 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3429 # @param theAxis Vector (or line, or linear edge), specifying
3430 # axis of the cylinder to find shapes on.
3431 # @param theRadius Radius of the cylinder to find shapes on.
3432 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3433 # @return List of all found sub-shapes indices.
3435 # @ref swig_GetShapesOnCylinderIDs "Example"
3436 def GetShapesOnCylinderIDs(self, theShape, theShapeType, theAxis, theRadius, theState):
3438 Find in theShape all sub-shapes of type theShapeType, situated relatively
3439 the specified cylinder by the certain way, defined through theState parameter.
3442 theShape Shape to find sub-shapes of.
3443 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3444 theAxis Vector (or line, or linear edge), specifying
3445 axis of the cylinder to find shapes on.
3446 theRadius Radius of the cylinder to find shapes on.
3447 theState The state of the sub-shapes to find (see GEOM::shape_state)
3450 List of all found sub-shapes indices.
3452 # Example: see GEOM_TestOthers.py
3453 aList = self.ShapesOp.GetShapesOnCylinderIDs(theShape, theShapeType, theAxis, theRadius, theState)
3454 RaiseIfFailed("GetShapesOnCylinderIDs", self.ShapesOp)
3457 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3458 # the specified cylinder by the certain way, defined through \a theState parameter.
3459 # @param theShape Shape to find sub-shapes of.
3460 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3461 # @param theAxis Vector (or line, or linear edge), specifying
3462 # axis of the cylinder to find shapes on.
3463 # @param thePnt Point specifying location of the bottom of the cylinder.
3464 # @param theRadius Radius of the cylinder to find shapes on.
3465 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3466 # @return List of all found sub-shapes.
3468 # @ref swig_GetShapesOnCylinderWithLocation "Example"
3469 def GetShapesOnCylinderWithLocation(self, theShape, theShapeType, theAxis, thePnt, theRadius, theState):
3471 Find in theShape all sub-shapes of type theShapeType, situated relatively
3472 the specified cylinder by the certain way, defined through theState parameter.
3475 theShape Shape to find sub-shapes of.
3476 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3477 theAxis Vector (or line, or linear edge), specifying
3478 axis of the cylinder to find shapes on.
3479 theRadius Radius of the cylinder to find shapes on.
3480 theState The state of the sub-shapes to find (see GEOM::shape_state)
3483 List of all found sub-shapes.
3485 # Example: see GEOM_TestOthers.py
3486 aList = self.ShapesOp.GetShapesOnCylinderWithLocation(theShape, theShapeType, theAxis, thePnt, theRadius, theState)
3487 RaiseIfFailed("GetShapesOnCylinderWithLocation", self.ShapesOp)
3490 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3491 # the specified cylinder by the certain way, defined through \a theState parameter.
3492 # @param theShape Shape to find sub-shapes of.
3493 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3494 # @param theAxis Vector (or line, or linear edge), specifying
3495 # axis of the cylinder to find shapes on.
3496 # @param thePnt Point specifying location of the bottom of the cylinder.
3497 # @param theRadius Radius of the cylinder to find shapes on.
3498 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3499 # @return List of all found sub-shapes indices
3501 # @ref swig_GetShapesOnCylinderWithLocationIDs "Example"
3502 def GetShapesOnCylinderWithLocationIDs(self, theShape, theShapeType, theAxis, thePnt, theRadius, theState):
3504 Find in theShape all sub-shapes of type theShapeType, situated relatively
3505 the specified cylinder by the certain way, defined through theState parameter.
3508 theShape Shape to find sub-shapes of.
3509 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3510 theAxis Vector (or line, or linear edge), specifying
3511 axis of the cylinder to find shapes on.
3512 theRadius Radius of the cylinder to find shapes on.
3513 theState The state of the sub-shapes to find (see GEOM::shape_state)
3516 List of all found sub-shapes indices.
3518 # Example: see GEOM_TestOthers.py
3519 aList = self.ShapesOp.GetShapesOnCylinderWithLocationIDs(theShape, theShapeType, theAxis, thePnt, theRadius, theState)
3520 RaiseIfFailed("GetShapesOnCylinderWithLocationIDs", self.ShapesOp)
3523 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3524 # the specified sphere by the certain way, defined through \a theState parameter.
3525 # @param theShape Shape to find sub-shapes of.
3526 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3527 # @param theCenter Point, specifying center of the sphere to find shapes on.
3528 # @param theRadius Radius of the sphere to find shapes on.
3529 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3530 # @return List of all found sub-shapes.
3532 # @ref swig_GetShapesOnSphere "Example"
3533 def GetShapesOnSphere(self,theShape, theShapeType, theCenter, theRadius, theState):
3535 Find in theShape all sub-shapes of type theShapeType, situated relatively
3536 the specified sphere by the certain way, defined through theState parameter.
3539 theShape Shape to find sub-shapes of.
3540 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3541 theCenter Point, specifying center of the sphere to find shapes on.
3542 theRadius Radius of the sphere to find shapes on.
3543 theState The state of the sub-shapes to find (see GEOM::shape_state)
3546 List of all found sub-shapes.
3548 # Example: see GEOM_TestOthers.py
3549 aList = self.ShapesOp.GetShapesOnSphere(theShape, theShapeType, theCenter, theRadius, theState)
3550 RaiseIfFailed("GetShapesOnSphere", self.ShapesOp)
3553 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3554 # the specified sphere by the certain way, defined through \a theState parameter.
3555 # @param theShape Shape to find sub-shapes of.
3556 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3557 # @param theCenter Point, specifying center of the sphere to find shapes on.
3558 # @param theRadius Radius of the sphere to find shapes on.
3559 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3560 # @return List of all found sub-shapes indices.
3562 # @ref swig_GetShapesOnSphereIDs "Example"
3563 def GetShapesOnSphereIDs(self,theShape, theShapeType, theCenter, theRadius, theState):
3565 Find in theShape all sub-shapes of type theShapeType, situated relatively
3566 the specified sphere by the certain way, defined through theState parameter.
3569 theShape Shape to find sub-shapes of.
3570 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3571 theCenter Point, specifying center of the sphere to find shapes on.
3572 theRadius Radius of the sphere to find shapes on.
3573 theState The state of the sub-shapes to find (see GEOM::shape_state)
3576 List of all found sub-shapes indices.
3578 # Example: see GEOM_TestOthers.py
3579 aList = self.ShapesOp.GetShapesOnSphereIDs(theShape, theShapeType, theCenter, theRadius, theState)
3580 RaiseIfFailed("GetShapesOnSphereIDs", self.ShapesOp)
3583 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3584 # the specified quadrangle by the certain way, defined through \a theState parameter.
3585 # @param theShape Shape to find sub-shapes of.
3586 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3587 # @param theTopLeftPoint Point, specifying top left corner of a quadrangle
3588 # @param theTopRigthPoint Point, specifying top right corner of a quadrangle
3589 # @param theBottomLeftPoint Point, specifying bottom left corner of a quadrangle
3590 # @param theBottomRigthPoint Point, specifying bottom right corner of a quadrangle
3591 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3592 # @return List of all found sub-shapes.
3594 # @ref swig_GetShapesOnQuadrangle "Example"
3595 def GetShapesOnQuadrangle(self, theShape, theShapeType,
3596 theTopLeftPoint, theTopRigthPoint,
3597 theBottomLeftPoint, theBottomRigthPoint, theState):
3599 Find in theShape all sub-shapes of type theShapeType, situated relatively
3600 the specified quadrangle by the certain way, defined through theState parameter.
3603 theShape Shape to find sub-shapes of.
3604 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3605 theTopLeftPoint Point, specifying top left corner of a quadrangle
3606 theTopRigthPoint Point, specifying top right corner of a quadrangle
3607 theBottomLeftPoint Point, specifying bottom left corner of a quadrangle
3608 theBottomRigthPoint Point, specifying bottom right corner of a quadrangle
3609 theState The state of the sub-shapes to find (see GEOM::shape_state)
3612 List of all found sub-shapes.
3614 # Example: see GEOM_TestOthers.py
3615 aList = self.ShapesOp.GetShapesOnQuadrangle(theShape, theShapeType,
3616 theTopLeftPoint, theTopRigthPoint,
3617 theBottomLeftPoint, theBottomRigthPoint, theState)
3618 RaiseIfFailed("GetShapesOnQuadrangle", self.ShapesOp)
3621 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3622 # the specified quadrangle by the certain way, defined through \a theState parameter.
3623 # @param theShape Shape to find sub-shapes of.
3624 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3625 # @param theTopLeftPoint Point, specifying top left corner of a quadrangle
3626 # @param theTopRigthPoint Point, specifying top right corner of a quadrangle
3627 # @param theBottomLeftPoint Point, specifying bottom left corner of a quadrangle
3628 # @param theBottomRigthPoint Point, specifying bottom right corner of a quadrangle
3629 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3630 # @return List of all found sub-shapes indices.
3632 # @ref swig_GetShapesOnQuadrangleIDs "Example"
3633 def GetShapesOnQuadrangleIDs(self, theShape, theShapeType,
3634 theTopLeftPoint, theTopRigthPoint,
3635 theBottomLeftPoint, theBottomRigthPoint, theState):
3637 Find in theShape all sub-shapes of type theShapeType, situated relatively
3638 the specified quadrangle by the certain way, defined through theState parameter.
3641 theShape Shape to find sub-shapes of.
3642 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3643 theTopLeftPoint Point, specifying top left corner of a quadrangle
3644 theTopRigthPoint Point, specifying top right corner of a quadrangle
3645 theBottomLeftPoint Point, specifying bottom left corner of a quadrangle
3646 theBottomRigthPoint Point, specifying bottom right corner of a quadrangle
3647 theState The state of the sub-shapes to find (see GEOM::shape_state)
3650 List of all found sub-shapes indices.
3653 # Example: see GEOM_TestOthers.py
3654 aList = self.ShapesOp.GetShapesOnQuadrangleIDs(theShape, theShapeType,
3655 theTopLeftPoint, theTopRigthPoint,
3656 theBottomLeftPoint, theBottomRigthPoint, theState)
3657 RaiseIfFailed("GetShapesOnQuadrangleIDs", self.ShapesOp)
3660 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3661 # the specified \a theBox by the certain way, defined through \a theState parameter.
3662 # @param theBox Shape for relative comparing.
3663 # @param theShape Shape to find sub-shapes of.
3664 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3665 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3666 # @return List of all found sub-shapes.
3668 # @ref swig_GetShapesOnBox "Example"
3669 def GetShapesOnBox(self, theBox, theShape, theShapeType, theState):
3671 Find in theShape all sub-shapes of type theShapeType, situated relatively
3672 the specified theBox by the certain way, defined through theState parameter.
3675 theBox Shape for relative comparing.
3676 theShape Shape to find sub-shapes of.
3677 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3678 theState The state of the sub-shapes to find (see GEOM::shape_state)
3681 List of all found sub-shapes.
3683 # Example: see GEOM_TestOthers.py
3684 aList = self.ShapesOp.GetShapesOnBox(theBox, theShape, theShapeType, theState)
3685 RaiseIfFailed("GetShapesOnBox", self.ShapesOp)
3688 ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3689 # the specified \a theBox by the certain way, defined through \a theState parameter.
3690 # @param theBox Shape for relative comparing.
3691 # @param theShape Shape to find sub-shapes of.
3692 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3693 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3694 # @return List of all found sub-shapes indices.
3696 # @ref swig_GetShapesOnBoxIDs "Example"
3697 def GetShapesOnBoxIDs(self, theBox, theShape, theShapeType, theState):
3699 Find in theShape all sub-shapes of type theShapeType, situated relatively
3700 the specified theBox by the certain way, defined through theState parameter.
3703 theBox Shape for relative comparing.
3704 theShape Shape to find sub-shapes of.
3705 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3706 theState The state of the sub-shapes to find (see GEOM::shape_state)
3709 List of all found sub-shapes indices.
3711 # Example: see GEOM_TestOthers.py
3712 aList = self.ShapesOp.GetShapesOnBoxIDs(theBox, theShape, theShapeType, theState)
3713 RaiseIfFailed("GetShapesOnBoxIDs", self.ShapesOp)
3716 ## Find in \a theShape all sub-shapes of type \a theShapeType,
3717 # situated relatively the specified \a theCheckShape by the
3718 # certain way, defined through \a theState parameter.
3719 # @param theCheckShape Shape for relative comparing. It must be a solid.
3720 # @param theShape Shape to find sub-shapes of.
3721 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3722 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3723 # @return List of all found sub-shapes.
3725 # @ref swig_GetShapesOnShape "Example"
3726 def GetShapesOnShape(self, theCheckShape, theShape, theShapeType, theState):
3728 Find in theShape all sub-shapes of type theShapeType,
3729 situated relatively the specified theCheckShape by the
3730 certain way, defined through theState parameter.
3733 theCheckShape Shape for relative comparing. It must be a solid.
3734 theShape Shape to find sub-shapes of.
3735 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3736 theState The state of the sub-shapes to find (see GEOM::shape_state)
3739 List of all found sub-shapes.
3741 # Example: see GEOM_TestOthers.py
3742 aList = self.ShapesOp.GetShapesOnShape(theCheckShape, theShape,
3743 theShapeType, theState)
3744 RaiseIfFailed("GetShapesOnShape", self.ShapesOp)
3747 ## Find in \a theShape all sub-shapes of type \a theShapeType,
3748 # situated relatively the specified \a theCheckShape by the
3749 # certain way, defined through \a theState parameter.
3750 # @param theCheckShape Shape for relative comparing. It must be a solid.
3751 # @param theShape Shape to find sub-shapes of.
3752 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3753 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3754 # @return All found sub-shapes as compound.
3756 # @ref swig_GetShapesOnShapeAsCompound "Example"
3757 def GetShapesOnShapeAsCompound(self, theCheckShape, theShape, theShapeType, theState):
3759 Find in theShape all sub-shapes of type theShapeType,
3760 situated relatively the specified theCheckShape by the
3761 certain way, defined through theState parameter.
3764 theCheckShape Shape for relative comparing. It must be a solid.
3765 theShape Shape to find sub-shapes of.
3766 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3767 theState The state of the sub-shapes to find (see GEOM::shape_state)
3770 All found sub-shapes as compound.
3772 # Example: see GEOM_TestOthers.py
3773 anObj = self.ShapesOp.GetShapesOnShapeAsCompound(theCheckShape, theShape,
3774 theShapeType, theState)
3775 RaiseIfFailed("GetShapesOnShapeAsCompound", self.ShapesOp)
3778 ## Find in \a theShape all sub-shapes of type \a theShapeType,
3779 # situated relatively the specified \a theCheckShape by the
3780 # certain way, defined through \a theState parameter.
3781 # @param theCheckShape Shape for relative comparing. It must be a solid.
3782 # @param theShape Shape to find sub-shapes of.
3783 # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3784 # @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3785 # @return List of all found sub-shapes indices.
3787 # @ref swig_GetShapesOnShapeIDs "Example"
3788 def GetShapesOnShapeIDs(self, theCheckShape, theShape, theShapeType, theState):
3790 Find in theShape all sub-shapes of type theShapeType,
3791 situated relatively the specified theCheckShape by the
3792 certain way, defined through theState parameter.
3795 theCheckShape Shape for relative comparing. It must be a solid.
3796 theShape Shape to find sub-shapes of.
3797 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3798 theState The state of the sub-shapes to find (see GEOM::shape_state)
3801 List of all found sub-shapes indices.
3803 # Example: see GEOM_TestOthers.py
3804 aList = self.ShapesOp.GetShapesOnShapeIDs(theCheckShape, theShape,
3805 theShapeType, theState)
3806 RaiseIfFailed("GetShapesOnShapeIDs", self.ShapesOp)
3809 ## Get sub-shape(s) of theShapeWhere, which are
3810 # coincident with \a theShapeWhat or could be a part of it.
3811 # @param theShapeWhere Shape to find sub-shapes of.
3812 # @param theShapeWhat Shape, specifying what to find.
3813 # @param isNewImplementation implementation of GetInPlace functionality
3814 # (default = False, old alghorithm based on shape properties)
3815 # @return Group of all found sub-shapes or a single found sub-shape.
3817 # @note This function has a restriction on argument shapes.
3818 # If \a theShapeWhere has curved parts with significantly
3819 # outstanding centres (i.e. the mass centre of a part is closer to
3820 # \a theShapeWhat than to the part), such parts will not be found.
3821 # @image html get_in_place_lost_part.png
3823 # @ref swig_GetInPlace "Example"
3824 def GetInPlace(self, theShapeWhere, theShapeWhat, isNewImplementation = False):
3826 Get sub-shape(s) of theShapeWhere, which are
3827 coincident with theShapeWhat or could be a part of it.
3830 theShapeWhere Shape to find sub-shapes of.
3831 theShapeWhat Shape, specifying what to find.
3832 isNewImplementation Implementation of GetInPlace functionality
3833 (default = False, old alghorithm based on shape properties)
3836 Group of all found sub-shapes or a single found sub-shape.
3840 This function has a restriction on argument shapes.
3841 If theShapeWhere has curved parts with significantly
3842 outstanding centres (i.e. the mass centre of a part is closer to
3843 theShapeWhat than to the part), such parts will not be found.
3845 # Example: see GEOM_TestOthers.py
3847 if isNewImplementation:
3848 anObj = self.ShapesOp.GetInPlace(theShapeWhere, theShapeWhat)
3850 anObj = self.ShapesOp.GetInPlaceOld(theShapeWhere, theShapeWhat)
3852 RaiseIfFailed("GetInPlace", self.ShapesOp)
3855 ## Get sub-shape(s) of \a theShapeWhere, which are
3856 # coincident with \a theShapeWhat or could be a part of it.
3858 # Implementation of this method is based on a saved history of an operation,
3859 # produced \a theShapeWhere. The \a theShapeWhat must be among this operation's
3860 # arguments (an argument shape or a sub-shape of an argument shape).
3861 # The operation could be the Partition or one of boolean operations,
3862 # performed on simple shapes (not on compounds).
3864 # @param theShapeWhere Shape to find sub-shapes of.
3865 # @param theShapeWhat Shape, specifying what to find (must be in the
3866 # building history of the ShapeWhere).
3867 # @return Group of all found sub-shapes or a single found sub-shape.
3869 # @ref swig_GetInPlace "Example"
3870 def GetInPlaceByHistory(self, theShapeWhere, theShapeWhat):
3872 Implementation of this method is based on a saved history of an operation,
3873 produced theShapeWhere. The theShapeWhat must be among this operation's
3874 arguments (an argument shape or a sub-shape of an argument shape).
3875 The operation could be the Partition or one of boolean operations,
3876 performed on simple shapes (not on compounds).
3879 theShapeWhere Shape to find sub-shapes of.
3880 theShapeWhat Shape, specifying what to find (must be in the
3881 building history of the ShapeWhere).
3884 Group of all found sub-shapes or a single found sub-shape.
3886 # Example: see GEOM_TestOthers.py
3887 anObj = self.ShapesOp.GetInPlaceByHistory(theShapeWhere, theShapeWhat)
3888 RaiseIfFailed("GetInPlaceByHistory", self.ShapesOp)
3891 ## Get sub-shape of theShapeWhere, which is
3892 # equal to \a theShapeWhat.
3893 # @param theShapeWhere Shape to find sub-shape of.
3894 # @param theShapeWhat Shape, specifying what to find.
3895 # @return New GEOM.GEOM_Object for found sub-shape.
3897 # @ref swig_GetSame "Example"
3898 def GetSame(self,theShapeWhere, theShapeWhat):
3900 Get sub-shape of theShapeWhere, which is
3901 equal to theShapeWhat.
3904 theShapeWhere Shape to find sub-shape of.
3905 theShapeWhat Shape, specifying what to find.
3908 New GEOM.GEOM_Object for found sub-shape.
3910 anObj = self.ShapesOp.GetSame(theShapeWhere, theShapeWhat)
3911 RaiseIfFailed("GetSame", self.ShapesOp)
3915 ## Get sub-shape indices of theShapeWhere, which is
3916 # equal to \a theShapeWhat.
3917 # @param theShapeWhere Shape to find sub-shape of.
3918 # @param theShapeWhat Shape, specifying what to find.
3919 # @return List of all found sub-shapes indices.
3921 # @ref swig_GetSame "Example"
3922 def GetSameIDs(self,theShapeWhere, theShapeWhat):
3924 Get sub-shape indices of theShapeWhere, which is
3925 equal to theShapeWhat.
3928 theShapeWhere Shape to find sub-shape of.
3929 theShapeWhat Shape, specifying what to find.
3932 List of all found sub-shapes indices.
3934 anObj = self.ShapesOp.GetSameIDs(theShapeWhere, theShapeWhat)
3935 RaiseIfFailed("GetSameIDs", self.ShapesOp)
3942 ## @addtogroup l4_access
3945 ## Obtain a composite sub-shape of <VAR>aShape</VAR>, composed from sub-shapes
3946 # of aShape, selected by their unique IDs inside <VAR>aShape</VAR>
3947 # @param aShape Shape to get sub-shape of.
3948 # @param ListOfID List of sub-shapes indices.
3949 # @return Found sub-shape.
3951 # @ref swig_all_decompose "Example"
3952 def GetSubShape(self, aShape, ListOfID):
3954 Obtain a composite sub-shape of aShape, composed from sub-shapes
3955 of aShape, selected by their unique IDs inside aShape
3958 aShape Shape to get sub-shape of.
3959 ListOfID List of sub-shapes indices.
3964 # Example: see GEOM_TestAll.py
3965 anObj = self.AddSubShape(aShape,ListOfID)
3968 ## Obtain unique ID of sub-shape <VAR>aSubShape</VAR> inside <VAR>aShape</VAR>
3969 # of aShape, selected by their unique IDs inside <VAR>aShape</VAR>
3970 # @param aShape Shape to get sub-shape of.
3971 # @param aSubShape Sub-shapes of aShape.
3972 # @return ID of found sub-shape.
3974 # @ref swig_all_decompose "Example"
3975 def GetSubShapeID(self, aShape, aSubShape):
3977 Obtain unique ID of sub-shape aSubShape inside aShape
3978 of aShape, selected by their unique IDs inside aShape
3981 aShape Shape to get sub-shape of.
3982 aSubShape Sub-shapes of aShape.
3985 ID of found sub-shape.
3987 # Example: see GEOM_TestAll.py
3988 anID = self.LocalOp.GetSubShapeIndex(aShape, aSubShape)
3989 RaiseIfFailed("GetSubShapeIndex", self.LocalOp)
3995 ## @addtogroup l4_decompose
3998 ## Get all sub-shapes and groups of \a theShape,
3999 # that were created already by any other methods.
4000 # @param theShape Any shape.
4001 # @param theGroupsOnly If this parameter is TRUE, only groups will be
4002 # returned, else all found sub-shapes and groups.
4003 # @return List of existing sub-objects of \a theShape.
4005 # @ref swig_all_decompose "Example"
4006 def GetExistingSubObjects(self, theShape, theGroupsOnly = False):
4008 Get all sub-shapes and groups of theShape,
4009 that were created already by any other methods.
4013 theGroupsOnly If this parameter is TRUE, only groups will be
4014 returned, else all found sub-shapes and groups.
4017 List of existing sub-objects of theShape.
4019 # Example: see GEOM_TestAll.py
4020 ListObj = self.ShapesOp.GetExistingSubObjects(theShape, theGroupsOnly)
4021 RaiseIfFailed("GetExistingSubObjects", self.ShapesOp)
4024 ## Get all groups of \a theShape,
4025 # that were created already by any other methods.
4026 # @param theShape Any shape.
4027 # @return List of existing groups of \a theShape.
4029 # @ref swig_all_decompose "Example"
4030 def GetGroups(self, theShape):
4032 Get all groups of theShape,
4033 that were created already by any other methods.
4039 List of existing groups of theShape.
4041 # Example: see GEOM_TestAll.py
4042 ListObj = self.ShapesOp.GetExistingSubObjects(theShape, True)
4043 RaiseIfFailed("GetExistingSubObjects", self.ShapesOp)
4046 ## Explode a shape on sub-shapes of a given type.
4047 # If the shape itself matches the type, it is also returned.
4048 # @param aShape Shape to be exploded.
4049 # @param aType Type of sub-shapes to be retrieved (see ShapeType())
4050 # @return List of sub-shapes of type theShapeType, contained in theShape.
4052 # @ref swig_all_decompose "Example"
4053 def SubShapeAll(self, aShape, aType):
4055 Explode a shape on sub-shapes of a given type.
4056 If the shape itself matches the type, it is also returned.
4059 aShape Shape to be exploded.
4060 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4063 List of sub-shapes of type theShapeType, contained in theShape.
4065 # Example: see GEOM_TestAll.py
4066 ListObj = self.ShapesOp.MakeAllSubShapes(aShape, aType, False)
4067 RaiseIfFailed("SubShapeAll", self.ShapesOp)
4070 ## Explode a shape on sub-shapes of a given type.
4071 # @param aShape Shape to be exploded.
4072 # @param aType Type of sub-shapes to be retrieved (see ShapeType())
4073 # @return List of IDs of sub-shapes.
4075 # @ref swig_all_decompose "Example"
4076 def SubShapeAllIDs(self, aShape, aType):
4078 Explode a shape on sub-shapes of a given type.
4081 aShape Shape to be exploded (see geompy.ShapeType)
4082 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4085 List of IDs of sub-shapes.
4087 ListObj = self.ShapesOp.GetAllSubShapesIDs(aShape, aType, False)
4088 RaiseIfFailed("SubShapeAllIDs", self.ShapesOp)
4091 ## Obtain a compound of sub-shapes of <VAR>aShape</VAR>,
4092 # selected by they indices in list of all sub-shapes of type <VAR>aType</VAR>.
4093 # Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
4094 # @param aShape Shape to get sub-shape of.
4095 # @param ListOfInd List of sub-shapes indices.
4096 # @param aType Type of sub-shapes to be retrieved (see ShapeType())
4097 # @return A compound of sub-shapes of aShape.
4099 # @ref swig_all_decompose "Example"
4100 def SubShape(self, aShape, aType, ListOfInd):
4102 Obtain a compound of sub-shapes of aShape,
4103 selected by they indices in list of all sub-shapes of type aType.
4104 Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
4107 aShape Shape to get sub-shape of.
4108 ListOfID List of sub-shapes indices.
4109 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4112 A compound of sub-shapes of aShape.
4114 # Example: see GEOM_TestAll.py
4116 AllShapeIDsList = self.SubShapeAllIDs(aShape, aType)
4117 for ind in ListOfInd:
4118 ListOfIDs.append(AllShapeIDsList[ind - 1])
4119 anObj = self.GetSubShape(aShape, ListOfIDs)
4122 ## Explode a shape on sub-shapes of a given type.
4123 # Sub-shapes will be sorted by coordinates of their gravity centers.
4124 # If the shape itself matches the type, it is also returned.
4125 # @param aShape Shape to be exploded.
4126 # @param aType Type of sub-shapes to be retrieved (see ShapeType())
4127 # @return List of sub-shapes of type theShapeType, contained in theShape.
4129 # @ref swig_SubShapeAllSorted "Example"
4130 def SubShapeAllSortedCentres(self, aShape, aType):
4132 Explode a shape on sub-shapes of a given type.
4133 Sub-shapes will be sorted by coordinates of their gravity centers.
4134 If the shape itself matches the type, it is also returned.
4137 aShape Shape to be exploded.
4138 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4141 List of sub-shapes of type theShapeType, contained in theShape.
4143 # Example: see GEOM_TestAll.py
4144 ListObj = self.ShapesOp.MakeAllSubShapes(aShape, aType, True)
4145 RaiseIfFailed("SubShapeAllSortedCentres", self.ShapesOp)
4148 ## Explode a shape on sub-shapes of a given type.
4149 # Sub-shapes will be sorted by coordinates of their gravity centers.
4150 # @param aShape Shape to be exploded.
4151 # @param aType Type of sub-shapes to be retrieved (see ShapeType())
4152 # @return List of IDs of sub-shapes.
4154 # @ref swig_all_decompose "Example"
4155 def SubShapeAllSortedCentresIDs(self, aShape, aType):
4157 Explode a shape on sub-shapes of a given type.
4158 Sub-shapes will be sorted by coordinates of their gravity centers.
4161 aShape Shape to be exploded.
4162 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4165 List of IDs of sub-shapes.
4167 ListIDs = self.ShapesOp.GetAllSubShapesIDs(aShape, aType, True)
4168 RaiseIfFailed("SubShapeAllIDs", self.ShapesOp)
4171 ## Obtain a compound of sub-shapes of <VAR>aShape</VAR>,
4172 # selected by they indices in sorted list of all sub-shapes of type <VAR>aType</VAR>.
4173 # Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
4174 # @param aShape Shape to get sub-shape of.
4175 # @param ListOfInd List of sub-shapes indices.
4176 # @param aType Type of sub-shapes to be retrieved (see ShapeType())
4177 # @return A compound of sub-shapes of aShape.
4179 # @ref swig_all_decompose "Example"
4180 def SubShapeSortedCentres(self, aShape, aType, ListOfInd):
4182 Obtain a compound of sub-shapes of aShape,
4183 selected by they indices in sorted list of all sub-shapes of type aType.
4184 Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
4187 aShape Shape to get sub-shape of.
4188 ListOfID List of sub-shapes indices.
4189 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4192 A compound of sub-shapes of aShape.
4194 # Example: see GEOM_TestAll.py
4196 AllShapeIDsList = self.SubShapeAllSortedCentresIDs(aShape, aType)
4197 for ind in ListOfInd:
4198 ListOfIDs.append(AllShapeIDsList[ind - 1])
4199 anObj = self.GetSubShape(aShape, ListOfIDs)
4202 ## Extract shapes (excluding the main shape) of given type.
4203 # @param aShape The shape.
4204 # @param aType The shape type (see ShapeType())
4205 # @param isSorted Boolean flag to switch sorting on/off.
4206 # @return List of sub-shapes of type aType, contained in aShape.
4208 # @ref swig_FilletChamfer "Example"
4209 def ExtractShapes(self, aShape, aType, isSorted = False):
4211 Extract shapes (excluding the main shape) of given type.
4215 aType The shape type (see geompy.ShapeType)
4216 isSorted Boolean flag to switch sorting on/off.
4219 List of sub-shapes of type aType, contained in aShape.
4221 # Example: see GEOM_TestAll.py
4222 ListObj = self.ShapesOp.ExtractSubShapes(aShape, aType, isSorted)
4223 RaiseIfFailed("ExtractSubShapes", self.ShapesOp)
4226 ## Get a set of sub-shapes defined by their unique IDs inside <VAR>aShape</VAR>
4227 # @param aShape Main shape.
4228 # @param anIDs List of unique IDs of sub-shapes inside <VAR>aShape</VAR>.
4229 # @return List of GEOM.GEOM_Object, corresponding to found sub-shapes.
4231 # @ref swig_all_decompose "Example"
4232 def SubShapes(self, aShape, anIDs):
4234 Get a set of sub-shapes defined by their unique IDs inside theMainShape
4238 anIDs List of unique IDs of sub-shapes inside theMainShape.
4241 List of GEOM.GEOM_Object, corresponding to found sub-shapes.
4243 # Example: see GEOM_TestAll.py
4244 ListObj = self.ShapesOp.MakeSubShapes(aShape, anIDs)
4245 RaiseIfFailed("SubShapes", self.ShapesOp)
4248 # end of l4_decompose
4251 ## @addtogroup l4_decompose_d
4254 ## Deprecated method
4255 # It works like SubShapeAllSortedCentres(), but wrongly
4256 # defines centres of faces, shells and solids.
4257 def SubShapeAllSorted(self, aShape, aType):
4260 It works like geompy.SubShapeAllSortedCentres, but wrongly
4261 defines centres of faces, shells and solids.
4263 ListObj = self.ShapesOp.MakeExplode(aShape, aType, True)
4264 RaiseIfFailed("MakeExplode", self.ShapesOp)
4267 ## Deprecated method
4268 # It works like SubShapeAllSortedCentresIDs(), but wrongly
4269 # defines centres of faces, shells and solids.
4270 def SubShapeAllSortedIDs(self, aShape, aType):
4273 It works like geompy.SubShapeAllSortedCentresIDs, but wrongly
4274 defines centres of faces, shells and solids.
4276 ListIDs = self.ShapesOp.SubShapeAllIDs(aShape, aType, True)
4277 RaiseIfFailed("SubShapeAllIDs", self.ShapesOp)
4280 ## Deprecated method
4281 # It works like SubShapeSortedCentres(), but has a bug
4282 # (wrongly defines centres of faces, shells and solids).
4283 def SubShapeSorted(self, aShape, aType, ListOfInd):
4286 It works like geompy.SubShapeSortedCentres, but has a bug
4287 (wrongly defines centres of faces, shells and solids).
4290 AllShapeIDsList = self.SubShapeAllSortedIDs(aShape, aType)
4291 for ind in ListOfInd:
4292 ListOfIDs.append(AllShapeIDsList[ind - 1])
4293 anObj = self.GetSubShape(aShape, ListOfIDs)
4296 # end of l4_decompose_d
4299 ## @addtogroup l3_healing
4302 ## Apply a sequence of Shape Healing operators to the given object.
4303 # @param theShape Shape to be processed.
4304 # @param theOperators List of names of operators ("FixShape", "SplitClosedFaces", etc.).
4305 # @param theParameters List of names of parameters
4306 # ("FixShape.Tolerance3d", "SplitClosedFaces.NbSplitPoints", etc.).
4307 # @param theValues List of values of parameters, in the same order
4308 # as parameters are listed in <VAR>theParameters</VAR> list.
4311 # <b> Operators and Parameters: </b> \n
4313 # * \b FixShape - corrects invalid shapes. \n
4314 # - \b FixShape.Tolerance3d - work tolerance for detection of the problems and correction of them. \n
4315 # - \b FixShape.MaxTolerance3d - maximal possible tolerance of the shape after correction. \n
4317 # * \b FixFaceSize - removes small faces, such as spots and strips.\n
4318 # - \b FixFaceSize.Tolerance - defines minimum possible face size. \n
4319 # - \b DropSmallEdges - removes edges, which merge with neighbouring edges. \n
4320 # - \b DropSmallEdges.Tolerance3d - defines minimum possible distance between two parallel edges.\n
4322 # * \b SplitAngle - splits faces based on conical surfaces, surfaces of revolution and cylindrical
4323 # surfaces in segments using a certain angle. \n
4324 # - \b SplitAngle.Angle - the central angle of the resulting segments (i.e. we obtain two segments
4325 # if Angle=180, four if Angle=90, etc). \n
4326 # - \b SplitAngle.MaxTolerance - maximum possible tolerance among the resulting segments.\n
4328 # * \b SplitClosedFaces - splits closed faces in segments.
4329 # The number of segments depends on the number of splitting points.\n
4330 # - \b SplitClosedFaces.NbSplitPoints - the number of splitting points.\n
4332 # * \b SplitContinuity - splits shapes to reduce continuities of curves and surfaces.\n
4333 # - \b SplitContinuity.Tolerance3d - 3D tolerance for correction of geometry.\n
4334 # - \b SplitContinuity.SurfaceContinuity - required continuity for surfaces.\n
4335 # - \b SplitContinuity.CurveContinuity - required continuity for curves.\n
4336 # This and the previous parameters can take the following values:\n
4337 # \b Parametric \b Continuity \n
4338 # \b C0 (Positional Continuity): curves are joined (the end positions of curves or surfaces
4339 # are coincidental. The curves or surfaces may still meet at an angle, giving rise to a sharp corner or edge).\n
4340 # \b C1 (Tangential Continuity): first derivatives are equal (the end vectors of curves or surfaces are parallel,
4341 # ruling out sharp edges).\n
4342 # \b C2 (Curvature Continuity): first and second derivatives are equal (the end vectors of curves or surfaces
4343 # are of the same magnitude).\n
4344 # \b CN N-th derivatives are equal (both the direction and the magnitude of the Nth derivatives of curves
4345 # or surfaces (d/du C(u)) are the same at junction. \n
4346 # \b Geometric \b Continuity \n
4347 # \b G1: first derivatives are proportional at junction.\n
4348 # The curve tangents thus have the same direction, but not necessarily the same magnitude.
4349 # i.e., C1'(1) = (a,b,c) and C2'(0) = (k*a, k*b, k*c).\n
4350 # \b G2: first and second derivatives are proportional at junction.
4351 # As the names imply, geometric continuity requires the geometry to be continuous, while parametric
4352 # continuity requires that the underlying parameterization was continuous as well.
4353 # Parametric continuity of order n implies geometric continuity of order n, but not vice-versa.\n
4355 # * \b BsplineRestriction - converts curves and surfaces to Bsplines and processes them with the following parameters:\n
4356 # - \b BSplineRestriction.SurfaceMode - approximation of surfaces if restriction is necessary.\n
4357 # - \b BSplineRestriction.Curve3dMode - conversion of any 3D curve to BSpline and approximation.\n
4358 # - \b BSplineRestriction.Curve2dMode - conversion of any 2D curve to BSpline and approximation.\n
4359 # - \b BSplineRestriction.Tolerance3d - defines the possibility of surfaces and 3D curves approximation
4360 # with the specified parameters.\n
4361 # - \b BSplineRestriction.Tolerance2d - defines the possibility of surfaces and 2D curves approximation
4362 # with the specified parameters.\n
4363 # - \b BSplineRestriction.RequiredDegree - required degree of the resulting BSplines.\n
4364 # - \b BSplineRestriction.RequiredNbSegments - required maximum number of segments of resultant BSplines.\n
4365 # - \b BSplineRestriction.Continuity3d - continuity of the resulting surfaces and 3D curves.\n
4366 # - \b BSplineRestriction.Continuity2d - continuity of the resulting 2D curves.\n
4368 # * \b ToBezier - converts curves and surfaces of any type to Bezier curves and surfaces.\n
4369 # - \b ToBezier.SurfaceMode - if checked in, allows conversion of surfaces.\n
4370 # - \b ToBezier.Curve3dMode - if checked in, allows conversion of 3D curves.\n
4371 # - \b ToBezier.Curve2dMode - if checked in, allows conversion of 2D curves.\n
4372 # - \b ToBezier.MaxTolerance - defines tolerance for detection and correction of problems.\n
4374 # * \b SameParameter - fixes edges of 2D and 3D curves not having the same parameter.\n
4375 # - \b SameParameter.Tolerance3d - defines tolerance for fixing of edges.\n
4378 # @return New GEOM.GEOM_Object, containing processed shape.
4380 # \n @ref tui_shape_processing "Example"
4381 def ProcessShape(self, theShape, theOperators, theParameters, theValues):
4383 Apply a sequence of Shape Healing operators to the given object.
4386 theShape Shape to be processed.
4387 theValues List of values of parameters, in the same order
4388 as parameters are listed in theParameters list.
4389 theOperators List of names of operators ("FixShape", "SplitClosedFaces", etc.).
4390 theParameters List of names of parameters
4391 ("FixShape.Tolerance3d", "SplitClosedFaces.NbSplitPoints", etc.).
4392 Operators and Parameters:
4394 * FixShape - corrects invalid shapes.
4395 * FixShape.Tolerance3d - work tolerance for detection of the problems and correction of them.
4396 * FixShape.MaxTolerance3d - maximal possible tolerance of the shape after correction.
4397 * FixFaceSize - removes small faces, such as spots and strips.
4398 * FixFaceSize.Tolerance - defines minimum possible face size.
4399 * DropSmallEdges - removes edges, which merge with neighbouring edges.
4400 * DropSmallEdges.Tolerance3d - defines minimum possible distance between two parallel edges.
4401 * SplitAngle - splits faces based on conical surfaces, surfaces of revolution and cylindrical surfaces
4402 in segments using a certain angle.
4403 * SplitAngle.Angle - the central angle of the resulting segments (i.e. we obtain two segments
4404 if Angle=180, four if Angle=90, etc).
4405 * SplitAngle.MaxTolerance - maximum possible tolerance among the resulting segments.
4406 * SplitClosedFaces - splits closed faces in segments. The number of segments depends on the number of
4408 * SplitClosedFaces.NbSplitPoints - the number of splitting points.
4409 * SplitContinuity - splits shapes to reduce continuities of curves and surfaces.
4410 * SplitContinuity.Tolerance3d - 3D tolerance for correction of geometry.
4411 * SplitContinuity.SurfaceContinuity - required continuity for surfaces.
4412 * SplitContinuity.CurveContinuity - required continuity for curves.
4413 This and the previous parameters can take the following values:
4415 Parametric Continuity:
4416 C0 (Positional Continuity): curves are joined (the end positions of curves or surfaces are
4417 coincidental. The curves or surfaces may still meet at an angle,
4418 giving rise to a sharp corner or edge).
4419 C1 (Tangential Continuity): first derivatives are equal (the end vectors of curves or surfaces
4420 are parallel, ruling out sharp edges).
4421 C2 (Curvature Continuity): first and second derivatives are equal (the end vectors of curves
4422 or surfaces are of the same magnitude).
4423 CN N-th derivatives are equal (both the direction and the magnitude of the Nth derivatives of
4424 curves or surfaces (d/du C(u)) are the same at junction.
4426 Geometric Continuity:
4427 G1: first derivatives are proportional at junction.
4428 The curve tangents thus have the same direction, but not necessarily the same magnitude.
4429 i.e., C1'(1) = (a,b,c) and C2'(0) = (k*a, k*b, k*c).
4430 G2: first and second derivatives are proportional at junction. As the names imply,
4431 geometric continuity requires the geometry to be continuous, while parametric continuity requires
4432 that the underlying parameterization was continuous as well. Parametric continuity of order n implies
4433 geometric continuity of order n, but not vice-versa.
4434 * BsplineRestriction - converts curves and surfaces to Bsplines and processes them with the following parameters:
4435 * BSplineRestriction.SurfaceMode - approximation of surfaces if restriction is necessary.
4436 * BSplineRestriction.Curve3dMode - conversion of any 3D curve to BSpline and approximation.
4437 * BSplineRestriction.Curve2dMode - conversion of any 2D curve to BSpline and approximation.
4438 * BSplineRestriction.Tolerance3d - defines the possibility of surfaces and 3D curves approximation with
4439 the specified parameters.
4440 * BSplineRestriction.Tolerance2d - defines the possibility of surfaces and 2D curves approximation with
4441 the specified parameters.
4442 * BSplineRestriction.RequiredDegree - required degree of the resulting BSplines.
4443 * BSplineRestriction.RequiredNbSegments - required maximum number of segments of resultant BSplines.
4444 * BSplineRestriction.Continuity3d - continuity of the resulting surfaces and 3D curves.
4445 * BSplineRestriction.Continuity2d - continuity of the resulting 2D curves.
4446 * ToBezier - converts curves and surfaces of any type to Bezier curves and surfaces.
4447 * ToBezier.SurfaceMode - if checked in, allows conversion of surfaces.
4448 * ToBezier.Curve3dMode - if checked in, allows conversion of 3D curves.
4449 * ToBezier.Curve2dMode - if checked in, allows conversion of 2D curves.
4450 * ToBezier.MaxTolerance - defines tolerance for detection and correction of problems.
4451 * SameParameter - fixes edges of 2D and 3D curves not having the same parameter.
4452 * SameParameter.Tolerance3d - defines tolerance for fixing of edges.
4455 New GEOM.GEOM_Object, containing processed shape.
4457 Note: For more information look through SALOME Geometry User's Guide->
4458 -> Introduction to Geometry-> Repairing Operations-> Shape Processing
4460 # Example: see GEOM_TestHealing.py
4461 theValues,Parameters = ParseList(theValues)
4462 anObj = self.HealOp.ProcessShape(theShape, theOperators, theParameters, theValues)
4463 # To avoid script failure in case of good argument shape
4464 if self.HealOp.GetErrorCode() == "ShHealOper_NotError_msg":
4466 RaiseIfFailed("ProcessShape", self.HealOp)
4467 for string in (theOperators + theParameters):
4468 Parameters = ":" + Parameters
4470 anObj.SetParameters(Parameters)
4473 ## Remove faces from the given object (shape).
4474 # @param theObject Shape to be processed.
4475 # @param theFaces Indices of faces to be removed, if EMPTY then the method
4476 # removes ALL faces of the given object.
4477 # @return New GEOM.GEOM_Object, containing processed shape.
4479 # @ref tui_suppress_faces "Example"
4480 def SuppressFaces(self,theObject, theFaces):
4482 Remove faces from the given object (shape).
4485 theObject Shape to be processed.
4486 theFaces Indices of faces to be removed, if EMPTY then the method
4487 removes ALL faces of the given object.
4490 New GEOM.GEOM_Object, containing processed shape.
4492 # Example: see GEOM_TestHealing.py
4493 anObj = self.HealOp.SuppressFaces(theObject, theFaces)
4494 RaiseIfFailed("SuppressFaces", self.HealOp)
4497 ## Sewing of some shapes into single shape.
4498 # @param ListShape Shapes to be processed.
4499 # @param theTolerance Required tolerance value.
4500 # @return New GEOM.GEOM_Object, containing processed shape.
4502 # @ref tui_sewing "Example"
4503 def MakeSewing(self, ListShape, theTolerance):
4505 Sewing of some shapes into single shape.
4508 ListShape Shapes to be processed.
4509 theTolerance Required tolerance value.
4512 New GEOM.GEOM_Object, containing processed shape.
4514 # Example: see GEOM_TestHealing.py
4515 comp = self.MakeCompound(ListShape)
4516 anObj = self.Sew(comp, theTolerance)
4519 ## Sewing of the given object.
4520 # @param theObject Shape to be processed.
4521 # @param theTolerance Required tolerance value.
4522 # @return New GEOM.GEOM_Object, containing processed shape.
4523 def Sew(self, theObject, theTolerance):
4525 Sewing of the given object.
4528 theObject Shape to be processed.
4529 theTolerance Required tolerance value.
4532 New GEOM.GEOM_Object, containing processed shape.
4534 # Example: see MakeSewing() above
4535 theTolerance,Parameters = ParseParameters(theTolerance)
4536 anObj = self.HealOp.Sew(theObject, theTolerance)
4537 RaiseIfFailed("Sew", self.HealOp)
4538 anObj.SetParameters(Parameters)
4541 ## Remove internal wires and edges from the given object (face).
4542 # @param theObject Shape to be processed.
4543 # @param theWires Indices of wires to be removed, if EMPTY then the method
4544 # removes ALL internal wires of the given object.
4545 # @return New GEOM.GEOM_Object, containing processed shape.
4547 # @ref tui_suppress_internal_wires "Example"
4548 def SuppressInternalWires(self,theObject, theWires):
4550 Remove internal wires and edges from the given object (face).
4553 theObject Shape to be processed.
4554 theWires Indices of wires to be removed, if EMPTY then the method
4555 removes ALL internal wires of the given object.
4558 New GEOM.GEOM_Object, containing processed shape.
4560 # Example: see GEOM_TestHealing.py
4561 anObj = self.HealOp.RemoveIntWires(theObject, theWires)
4562 RaiseIfFailed("RemoveIntWires", self.HealOp)
4565 ## Remove internal closed contours (holes) from the given object.
4566 # @param theObject Shape to be processed.
4567 # @param theWires Indices of wires to be removed, if EMPTY then the method
4568 # removes ALL internal holes of the given object
4569 # @return New GEOM.GEOM_Object, containing processed shape.
4571 # @ref tui_suppress_holes "Example"
4572 def SuppressHoles(self,theObject, theWires):
4574 Remove internal closed contours (holes) from the given object.
4577 theObject Shape to be processed.
4578 theWires Indices of wires to be removed, if EMPTY then the method
4579 removes ALL internal holes of the given object
4582 New GEOM.GEOM_Object, containing processed shape.
4584 # Example: see GEOM_TestHealing.py
4585 anObj = self.HealOp.FillHoles(theObject, theWires)
4586 RaiseIfFailed("FillHoles", self.HealOp)
4589 ## Close an open wire.
4590 # @param theObject Shape to be processed.
4591 # @param theWires Indexes of edge(s) and wire(s) to be closed within <VAR>theObject</VAR>'s shape,
4592 # if [ ], then <VAR>theObject</VAR> itself is a wire.
4593 # @param isCommonVertex If True : closure by creation of a common vertex,
4594 # If False : closure by creation of an edge between ends.
4595 # @return New GEOM.GEOM_Object, containing processed shape.
4597 # @ref tui_close_contour "Example"
4598 def CloseContour(self,theObject, theWires, isCommonVertex):
4603 theObject Shape to be processed.
4604 theWires Indexes of edge(s) and wire(s) to be closed within theObject's shape,
4605 if [ ], then theObject itself is a wire.
4606 isCommonVertex If True : closure by creation of a common vertex,
4607 If False : closure by creation of an edge between ends.
4610 New GEOM.GEOM_Object, containing processed shape.
4612 # Example: see GEOM_TestHealing.py
4613 anObj = self.HealOp.CloseContour(theObject, theWires, isCommonVertex)
4614 RaiseIfFailed("CloseContour", self.HealOp)
4617 ## Addition of a point to a given edge object.
4618 # @param theObject Shape to be processed.
4619 # @param theEdgeIndex Index of edge to be divided within theObject's shape,
4620 # if -1, then theObject itself is the edge.
4621 # @param theValue Value of parameter on edge or length parameter,
4622 # depending on \a isByParameter.
4623 # @param isByParameter If TRUE : \a theValue is treated as a curve parameter [0..1], \n
4624 # if FALSE : \a theValue is treated as a length parameter [0..1]
4625 # @return New GEOM.GEOM_Object, containing processed shape.
4627 # @ref tui_add_point_on_edge "Example"
4628 def DivideEdge(self,theObject, theEdgeIndex, theValue, isByParameter):
4630 Addition of a point to a given edge object.
4633 theObject Shape to be processed.
4634 theEdgeIndex Index of edge to be divided within theObject's shape,
4635 if -1, then theObject itself is the edge.
4636 theValue Value of parameter on edge or length parameter,
4637 depending on isByParameter.
4638 isByParameter If TRUE : theValue is treated as a curve parameter [0..1],
4639 if FALSE : theValue is treated as a length parameter [0..1]
4642 New GEOM.GEOM_Object, containing processed shape.
4644 # Example: see GEOM_TestHealing.py
4645 theEdgeIndex,theValue,isByParameter,Parameters = ParseParameters(theEdgeIndex,theValue,isByParameter)
4646 anObj = self.HealOp.DivideEdge(theObject, theEdgeIndex, theValue, isByParameter)
4647 RaiseIfFailed("DivideEdge", self.HealOp)
4648 anObj.SetParameters(Parameters)
4651 ## Suppress the vertices in the wire in case if adjacent edges are C1 continuous.
4652 # @param theWire Wire to minimize the number of C1 continuous edges in.
4653 # @param theVertices A list of vertices to suppress. If the list
4654 # is empty, all vertices in a wire will be assumed.
4655 # @return New GEOM.GEOM_Object with modified wire.
4657 # @ref tui_fuse_collinear_edges "Example"
4658 def FuseCollinearEdgesWithinWire(self, theWire, theVertices = []):
4660 Suppress the vertices in the wire in case if adjacent edges are C1 continuous.
4663 theWire Wire to minimize the number of C1 continuous edges in.
4664 theVertices A list of vertices to suppress. If the list
4665 is empty, all vertices in a wire will be assumed.
4668 New GEOM.GEOM_Object with modified wire.
4670 anObj = self.HealOp.FuseCollinearEdgesWithinWire(theWire, theVertices)
4671 RaiseIfFailed("FuseCollinearEdgesWithinWire", self.HealOp)
4674 ## Change orientation of the given object. Updates given shape.
4675 # @param theObject Shape to be processed.
4676 # @return Updated <var>theObject</var>
4678 # @ref swig_todo "Example"
4679 def ChangeOrientationShell(self,theObject):
4681 Change orientation of the given object. Updates given shape.
4684 theObject Shape to be processed.
4689 theObject = self.HealOp.ChangeOrientation(theObject)
4690 RaiseIfFailed("ChangeOrientation", self.HealOp)
4693 ## Change orientation of the given object.
4694 # @param theObject Shape to be processed.
4695 # @return New GEOM.GEOM_Object, containing processed shape.
4697 # @ref swig_todo "Example"
4698 def ChangeOrientationShellCopy(self, theObject):
4700 Change orientation of the given object.
4703 theObject Shape to be processed.
4706 New GEOM.GEOM_Object, containing processed shape.
4708 anObj = self.HealOp.ChangeOrientationCopy(theObject)
4709 RaiseIfFailed("ChangeOrientationCopy", self.HealOp)
4712 ## Try to limit tolerance of the given object by value \a theTolerance.
4713 # @param theObject Shape to be processed.
4714 # @param theTolerance Required tolerance value.
4715 # @return New GEOM.GEOM_Object, containing processed shape.
4717 # @ref tui_limit_tolerance "Example"
4718 def LimitTolerance(self, theObject, theTolerance = 1e-07):
4720 Try to limit tolerance of the given object by value theTolerance.
4723 theObject Shape to be processed.
4724 theTolerance Required tolerance value.
4727 New GEOM.GEOM_Object, containing processed shape.
4729 anObj = self.HealOp.LimitTolerance(theObject, theTolerance)
4730 RaiseIfFailed("LimitTolerance", self.HealOp)
4733 ## Get a list of wires (wrapped in GEOM.GEOM_Object-s),
4734 # that constitute a free boundary of the given shape.
4735 # @param theObject Shape to get free boundary of.
4736 # @return [\a status, \a theClosedWires, \a theOpenWires]
4737 # \n \a status: FALSE, if an error(s) occured during the method execution.
4738 # \n \a theClosedWires: Closed wires on the free boundary of the given shape.
4739 # \n \a theOpenWires: Open wires on the free boundary of the given shape.
4741 # @ref tui_measurement_tools_page "Example"
4742 def GetFreeBoundary(self, theObject):
4744 Get a list of wires (wrapped in GEOM.GEOM_Object-s),
4745 that constitute a free boundary of the given shape.
4748 theObject Shape to get free boundary of.
4751 [status, theClosedWires, theOpenWires]
4752 status: FALSE, if an error(s) occured during the method execution.
4753 theClosedWires: Closed wires on the free boundary of the given shape.
4754 theOpenWires: Open wires on the free boundary of the given shape.
4756 # Example: see GEOM_TestHealing.py
4757 anObj = self.HealOp.GetFreeBoundary(theObject)
4758 RaiseIfFailed("GetFreeBoundary", self.HealOp)
4761 ## Replace coincident faces in theShape by one face.
4762 # @param theShape Initial shape.
4763 # @param theTolerance Maximum distance between faces, which can be considered as coincident.
4764 # @param doKeepNonSolids If FALSE, only solids will present in the result,
4765 # otherwise all initial shapes.
4766 # @return New GEOM.GEOM_Object, containing a copy of theShape without coincident faces.
4768 # @ref tui_glue_faces "Example"
4769 def MakeGlueFaces(self, theShape, theTolerance, doKeepNonSolids=True):
4771 Replace coincident faces in theShape by one face.
4774 theShape Initial shape.
4775 theTolerance Maximum distance between faces, which can be considered as coincident.
4776 doKeepNonSolids If FALSE, only solids will present in the result,
4777 otherwise all initial shapes.
4780 New GEOM.GEOM_Object, containing a copy of theShape without coincident faces.
4782 # Example: see GEOM_Spanner.py
4783 theTolerance,Parameters = ParseParameters(theTolerance)
4784 anObj = self.ShapesOp.MakeGlueFaces(theShape, theTolerance, doKeepNonSolids)
4786 raise RuntimeError, "MakeGlueFaces : " + self.ShapesOp.GetErrorCode()
4787 anObj.SetParameters(Parameters)
4790 ## Find coincident faces in theShape for possible gluing.
4791 # @param theShape Initial shape.
4792 # @param theTolerance Maximum distance between faces,
4793 # which can be considered as coincident.
4794 # @return GEOM.ListOfGO
4796 # @ref tui_glue_faces "Example"
4797 def GetGlueFaces(self, theShape, theTolerance):
4799 Find coincident faces in theShape for possible gluing.
4802 theShape Initial shape.
4803 theTolerance Maximum distance between faces,
4804 which can be considered as coincident.
4809 anObj = self.ShapesOp.GetGlueFaces(theShape, theTolerance)
4810 RaiseIfFailed("GetGlueFaces", self.ShapesOp)
4813 ## Replace coincident faces in theShape by one face
4814 # in compliance with given list of faces
4815 # @param theShape Initial shape.
4816 # @param theTolerance Maximum distance between faces,
4817 # which can be considered as coincident.
4818 # @param theFaces List of faces for gluing.
4819 # @param doKeepNonSolids If FALSE, only solids will present in the result,
4820 # otherwise all initial shapes.
4821 # @param doGlueAllEdges If TRUE, all coincident edges of <VAR>theShape</VAR>
4822 # will be glued, otherwise only the edges,
4823 # belonging to <VAR>theFaces</VAR>.
4824 # @return New GEOM.GEOM_Object, containing a copy of theShape
4825 # without some faces.
4827 # @ref tui_glue_faces "Example"
4828 def MakeGlueFacesByList(self, theShape, theTolerance, theFaces,
4829 doKeepNonSolids=True, doGlueAllEdges=True):
4831 Replace coincident faces in theShape by one face
4832 in compliance with given list of faces
4835 theShape Initial shape.
4836 theTolerance Maximum distance between faces,
4837 which can be considered as coincident.
4838 theFaces List of faces for gluing.
4839 doKeepNonSolids If FALSE, only solids will present in the result,
4840 otherwise all initial shapes.
4841 doGlueAllEdges If TRUE, all coincident edges of theShape
4842 will be glued, otherwise only the edges,
4843 belonging to theFaces.
4846 New GEOM.GEOM_Object, containing a copy of theShape
4849 anObj = self.ShapesOp.MakeGlueFacesByList(theShape, theTolerance, theFaces,
4850 doKeepNonSolids, doGlueAllEdges)
4852 raise RuntimeError, "MakeGlueFacesByList : " + self.ShapesOp.GetErrorCode()
4855 ## Replace coincident edges in theShape by one edge.
4856 # @param theShape Initial shape.
4857 # @param theTolerance Maximum distance between edges, which can be considered as coincident.
4858 # @return New GEOM.GEOM_Object, containing a copy of theShape without coincident edges.
4860 # @ref tui_glue_edges "Example"
4861 def MakeGlueEdges(self, theShape, theTolerance):
4863 Replace coincident edges in theShape by one edge.
4866 theShape Initial shape.
4867 theTolerance Maximum distance between edges, which can be considered as coincident.
4870 New GEOM.GEOM_Object, containing a copy of theShape without coincident edges.
4872 theTolerance,Parameters = ParseParameters(theTolerance)
4873 anObj = self.ShapesOp.MakeGlueEdges(theShape, theTolerance)
4875 raise RuntimeError, "MakeGlueEdges : " + self.ShapesOp.GetErrorCode()
4876 anObj.SetParameters(Parameters)
4879 ## Find coincident edges in theShape for possible gluing.
4880 # @param theShape Initial shape.
4881 # @param theTolerance Maximum distance between edges,
4882 # which can be considered as coincident.
4883 # @return GEOM.ListOfGO
4885 # @ref tui_glue_edges "Example"
4886 def GetGlueEdges(self, theShape, theTolerance):
4888 Find coincident edges in theShape for possible gluing.
4891 theShape Initial shape.
4892 theTolerance Maximum distance between edges,
4893 which can be considered as coincident.
4898 anObj = self.ShapesOp.GetGlueEdges(theShape, theTolerance)
4899 RaiseIfFailed("GetGlueEdges", self.ShapesOp)
4902 ## Replace coincident edges in theShape by one edge
4903 # in compliance with given list of edges.
4904 # @param theShape Initial shape.
4905 # @param theTolerance Maximum distance between edges,
4906 # which can be considered as coincident.
4907 # @param theEdges List of edges for gluing.
4908 # @return New GEOM.GEOM_Object, containing a copy of theShape
4909 # without some edges.
4911 # @ref tui_glue_edges "Example"
4912 def MakeGlueEdgesByList(self, theShape, theTolerance, theEdges):
4914 Replace coincident edges in theShape by one edge
4915 in compliance with given list of edges.
4918 theShape Initial shape.
4919 theTolerance Maximum distance between edges,
4920 which can be considered as coincident.
4921 theEdges List of edges for gluing.
4924 New GEOM.GEOM_Object, containing a copy of theShape
4927 anObj = self.ShapesOp.MakeGlueEdgesByList(theShape, theTolerance, theEdges)
4929 raise RuntimeError, "MakeGlueEdgesByList : " + self.ShapesOp.GetErrorCode()
4935 ## @addtogroup l3_boolean Boolean Operations
4938 # -----------------------------------------------------------------------------
4939 # Boolean (Common, Cut, Fuse, Section)
4940 # -----------------------------------------------------------------------------
4942 ## Perform one of boolean operations on two given shapes.
4943 # @param theShape1 First argument for boolean operation.
4944 # @param theShape2 Second argument for boolean operation.
4945 # @param theOperation Indicates the operation to be done:\n
4946 # 1 - Common, 2 - Cut, 3 - Fuse, 4 - Section.
4947 # @return New GEOM.GEOM_Object, containing the result shape.
4949 # @ref tui_fuse "Example"
4950 def MakeBoolean(self,theShape1, theShape2, theOperation):
4952 Perform one of boolean operations on two given shapes.
4955 theShape1 First argument for boolean operation.
4956 theShape2 Second argument for boolean operation.
4957 theOperation Indicates the operation to be done:
4958 1 - Common, 2 - Cut, 3 - Fuse, 4 - Section.
4961 New GEOM.GEOM_Object, containing the result shape.
4963 # Example: see GEOM_TestAll.py
4964 anObj = self.BoolOp.MakeBoolean(theShape1, theShape2, theOperation)
4965 RaiseIfFailed("MakeBoolean", self.BoolOp)
4968 ## Perform Common boolean operation on two given shapes.
4969 # @param theShape1 First argument for boolean operation.
4970 # @param theShape2 Second argument for boolean operation.
4971 # @return New GEOM.GEOM_Object, containing the result shape.
4973 # @ref tui_common "Example 1"
4974 # \n @ref swig_MakeCommon "Example 2"
4975 def MakeCommon(self, theShape1, theShape2):
4977 Perform Common boolean operation on two given shapes.
4980 theShape1 First argument for boolean operation.
4981 theShape2 Second argument for boolean operation.
4984 New GEOM.GEOM_Object, containing the result shape.
4986 # Example: see GEOM_TestOthers.py
4987 return self.MakeBoolean(theShape1, theShape2, 1)
4989 ## Perform Cut boolean operation on two given shapes.
4990 # @param theShape1 First argument for boolean operation.
4991 # @param theShape2 Second argument for boolean operation.
4992 # @return New GEOM.GEOM_Object, containing the result shape.
4994 # @ref tui_cut "Example 1"
4995 # \n @ref swig_MakeCommon "Example 2"
4996 def MakeCut(self, theShape1, theShape2):
4998 Perform Cut boolean operation on two given shapes.
5001 theShape1 First argument for boolean operation.
5002 theShape2 Second argument for boolean operation.
5005 New GEOM.GEOM_Object, containing the result shape.
5008 # Example: see GEOM_TestOthers.py
5009 return self.MakeBoolean(theShape1, theShape2, 2)
5011 ## Perform Fuse boolean operation on two given shapes.
5012 # @param theShape1 First argument for boolean operation.
5013 # @param theShape2 Second argument for boolean operation.
5014 # @return New GEOM.GEOM_Object, containing the result shape.
5016 # @ref tui_fuse "Example 1"
5017 # \n @ref swig_MakeCommon "Example 2"
5018 def MakeFuse(self, theShape1, theShape2):
5020 Perform Fuse boolean operation on two given shapes.
5023 theShape1 First argument for boolean operation.
5024 theShape2 Second argument for boolean operation.
5027 New GEOM.GEOM_Object, containing the result shape.
5030 # Example: see GEOM_TestOthers.py
5031 return self.MakeBoolean(theShape1, theShape2, 3)
5033 ## Perform Section boolean operation on two given shapes.
5034 # @param theShape1 First argument for boolean operation.
5035 # @param theShape2 Second argument for boolean operation.
5036 # @return New GEOM.GEOM_Object, containing the result shape.
5038 # @ref tui_section "Example 1"
5039 # \n @ref swig_MakeCommon "Example 2"
5040 def MakeSection(self, theShape1, theShape2):
5042 Perform Section boolean operation on two given shapes.
5045 theShape1 First argument for boolean operation.
5046 theShape2 Second argument for boolean operation.
5049 New GEOM.GEOM_Object, containing the result shape.
5052 # Example: see GEOM_TestOthers.py
5053 return self.MakeBoolean(theShape1, theShape2, 4)
5058 ## @addtogroup l3_basic_op
5061 ## Perform partition operation.
5062 # @param ListShapes Shapes to be intersected.
5063 # @param ListTools Shapes to intersect theShapes.
5064 # @param Limit Type of resulting shapes (see ShapeType()).\n
5065 # If this parameter is set to -1 ("Auto"), most appropriate shape limit
5066 # type will be detected automatically.
5067 # @param KeepNonlimitShapes if this parameter == 0, then only shapes of
5068 # target type (equal to Limit) are kept in the result,
5069 # else standalone shapes of lower dimension
5070 # are kept also (if they exist).
5071 # @note Each compound from ListShapes and ListTools will be exploded
5072 # in order to avoid possible intersection between shapes from this compound.
5074 # After implementation new version of PartitionAlgo (October 2006)
5075 # other parameters are ignored by current functionality. They are kept
5076 # in this function only for support old versions.
5077 # @param ListKeepInside Shapes, outside which the results will be deleted.
5078 # Each shape from theKeepInside must belong to theShapes also.
5079 # @param ListRemoveInside Shapes, inside which the results will be deleted.
5080 # Each shape from theRemoveInside must belong to theShapes also.
5081 # @param RemoveWebs If TRUE, perform Glue 3D algorithm.
5082 # @param ListMaterials Material indices for each shape. Make sence,
5083 # only if theRemoveWebs is TRUE.
5085 # @return New GEOM.GEOM_Object, containing the result shapes.
5087 # @ref tui_partition "Example"
5088 def MakePartition(self, ListShapes, ListTools=[], ListKeepInside=[], ListRemoveInside=[],
5089 Limit=ShapeType["AUTO"], RemoveWebs=0, ListMaterials=[],
5090 KeepNonlimitShapes=0):
5092 Perform partition operation.
5095 ListShapes Shapes to be intersected.
5096 ListTools Shapes to intersect theShapes.
5097 Limit Type of resulting shapes (see geompy.ShapeType)
5098 If this parameter is set to -1 ("Auto"), most appropriate shape limit
5099 type will be detected automatically.
5100 KeepNonlimitShapes if this parameter == 0, then only shapes of
5101 target type (equal to Limit) are kept in the result,
5102 else standalone shapes of lower dimension
5103 are kept also (if they exist).
5105 Each compound from ListShapes and ListTools will be exploded
5106 in order to avoid possible intersection between shapes from
5109 After implementation new version of PartitionAlgo (October 2006) other
5110 parameters are ignored by current functionality. They are kept in this
5111 function only for support old versions.
5114 ListKeepInside Shapes, outside which the results will be deleted.
5115 Each shape from theKeepInside must belong to theShapes also.
5116 ListRemoveInside Shapes, inside which the results will be deleted.
5117 Each shape from theRemoveInside must belong to theShapes also.
5118 RemoveWebs If TRUE, perform Glue 3D algorithm.
5119 ListMaterials Material indices for each shape. Make sence, only if theRemoveWebs is TRUE.
5122 New GEOM.GEOM_Object, containing the result shapes.
5124 # Example: see GEOM_TestAll.py
5125 if Limit == ShapeType["AUTO"]:
5126 # automatic detection of the most appropriate shape limit type
5128 for s in ListShapes: lim = min( lim, s.GetMaxShapeType() )
5129 Limit = EnumToLong(lim)
5131 anObj = self.BoolOp.MakePartition(ListShapes, ListTools,
5132 ListKeepInside, ListRemoveInside,
5133 Limit, RemoveWebs, ListMaterials,
5134 KeepNonlimitShapes);
5135 RaiseIfFailed("MakePartition", self.BoolOp)
5138 ## Perform partition operation.
5139 # This method may be useful if it is needed to make a partition for
5140 # compound contains nonintersected shapes. Performance will be better
5141 # since intersection between shapes from compound is not performed.
5143 # Description of all parameters as in previous method MakePartition()
5145 # @note Passed compounds (via ListShapes or via ListTools)
5146 # have to consist of nonintersecting shapes.
5148 # @return New GEOM.GEOM_Object, containing the result shapes.
5150 # @ref swig_todo "Example"
5151 def MakePartitionNonSelfIntersectedShape(self, ListShapes, ListTools=[],
5152 ListKeepInside=[], ListRemoveInside=[],
5153 Limit=ShapeType["AUTO"], RemoveWebs=0,
5154 ListMaterials=[], KeepNonlimitShapes=0):
5156 Perform partition operation.
5157 This method may be useful if it is needed to make a partition for
5158 compound contains nonintersected shapes. Performance will be better
5159 since intersection between shapes from compound is not performed.
5162 Description of all parameters as in method geompy.MakePartition
5165 Passed compounds (via ListShapes or via ListTools)
5166 have to consist of nonintersecting shapes.
5169 New GEOM.GEOM_Object, containing the result shapes.
5171 if Limit == ShapeType["AUTO"]:
5172 # automatic detection of the most appropriate shape limit type
5174 for s in ListShapes: lim = min( lim, s.GetMaxShapeType() )
5175 Limit = EnumToLong(lim)
5177 anObj = self.BoolOp.MakePartitionNonSelfIntersectedShape(ListShapes, ListTools,
5178 ListKeepInside, ListRemoveInside,
5179 Limit, RemoveWebs, ListMaterials,
5180 KeepNonlimitShapes);
5181 RaiseIfFailed("MakePartitionNonSelfIntersectedShape", self.BoolOp)
5184 ## See method MakePartition() for more information.
5186 # @ref tui_partition "Example 1"
5187 # \n @ref swig_Partition "Example 2"
5188 def Partition(self, ListShapes, ListTools=[], ListKeepInside=[], ListRemoveInside=[],
5189 Limit=ShapeType["AUTO"], RemoveWebs=0, ListMaterials=[],
5190 KeepNonlimitShapes=0):
5192 See method geompy.MakePartition for more information.
5194 # Example: see GEOM_TestOthers.py
5195 anObj = self.MakePartition(ListShapes, ListTools,
5196 ListKeepInside, ListRemoveInside,
5197 Limit, RemoveWebs, ListMaterials,
5198 KeepNonlimitShapes);
5201 ## Perform partition of the Shape with the Plane
5202 # @param theShape Shape to be intersected.
5203 # @param thePlane Tool shape, to intersect theShape.
5204 # @return New GEOM.GEOM_Object, containing the result shape.
5206 # @ref tui_partition "Example"
5207 def MakeHalfPartition(self,theShape, thePlane):
5209 Perform partition of the Shape with the Plane
5212 theShape Shape to be intersected.
5213 thePlane Tool shape, to intersect theShape.
5216 New GEOM.GEOM_Object, containing the result shape.
5218 # Example: see GEOM_TestAll.py
5219 anObj = self.BoolOp.MakeHalfPartition(theShape, thePlane)
5220 RaiseIfFailed("MakeHalfPartition", self.BoolOp)
5223 # end of l3_basic_op
5226 ## @addtogroup l3_transform
5229 ## Translate the given object along the vector, specified
5230 # by its end points, creating its copy before the translation.
5231 # @param theObject The object to be translated.
5232 # @param thePoint1 Start point of translation vector.
5233 # @param thePoint2 End point of translation vector.
5234 # @return New GEOM.GEOM_Object, containing the translated object.
5236 # @ref tui_translation "Example 1"
5237 # \n @ref swig_MakeTranslationTwoPoints "Example 2"
5238 def MakeTranslationTwoPoints(self,theObject, thePoint1, thePoint2):
5240 Translate the given object along the vector, specified
5241 by its end points, creating its copy before the translation.
5244 theObject The object to be translated.
5245 thePoint1 Start point of translation vector.
5246 thePoint2 End point of translation vector.
5249 New GEOM.GEOM_Object, containing the translated object.
5251 # Example: see GEOM_TestAll.py
5252 anObj = self.TrsfOp.TranslateTwoPointsCopy(theObject, thePoint1, thePoint2)
5253 RaiseIfFailed("TranslateTwoPointsCopy", self.TrsfOp)
5256 ## Translate the given object along the vector, specified by its components.
5257 # @param theObject The object to be translated.
5258 # @param theDX,theDY,theDZ Components of translation vector.
5259 # @return Translated GEOM.GEOM_Object.
5261 # @ref tui_translation "Example"
5262 def TranslateDXDYDZ(self,theObject, theDX, theDY, theDZ):
5264 Translate the given object along the vector, specified by its components.
5267 theObject The object to be translated.
5268 theDX,theDY,theDZ Components of translation vector.
5271 Translated GEOM.GEOM_Object.
5273 # Example: see GEOM_TestAll.py
5274 theDX, theDY, theDZ, Parameters = ParseParameters(theDX, theDY, theDZ)
5275 anObj = self.TrsfOp.TranslateDXDYDZ(theObject, theDX, theDY, theDZ)
5276 anObj.SetParameters(Parameters)
5277 RaiseIfFailed("TranslateDXDYDZ", self.TrsfOp)
5280 ## Translate the given object along the vector, specified
5281 # by its components, creating its copy before the translation.
5282 # @param theObject The object to be translated.
5283 # @param theDX,theDY,theDZ Components of translation vector.
5284 # @return New GEOM.GEOM_Object, containing the translated object.
5286 # @ref tui_translation "Example"
5287 def MakeTranslation(self,theObject, theDX, theDY, theDZ):
5289 Translate the given object along the vector, specified
5290 by its components, creating its copy before the translation.
5293 theObject The object to be translated.
5294 theDX,theDY,theDZ Components of translation vector.
5297 New GEOM.GEOM_Object, containing the translated object.
5299 # Example: see GEOM_TestAll.py
5300 theDX, theDY, theDZ, Parameters = ParseParameters(theDX, theDY, theDZ)
5301 anObj = self.TrsfOp.TranslateDXDYDZCopy(theObject, theDX, theDY, theDZ)
5302 anObj.SetParameters(Parameters)
5303 RaiseIfFailed("TranslateDXDYDZ", self.TrsfOp)
5306 ## Translate the given object along the given vector,
5307 # creating its copy before the translation.
5308 # @param theObject The object to be translated.
5309 # @param theVector The translation vector.
5310 # @return New GEOM.GEOM_Object, containing the translated object.
5312 # @ref tui_translation "Example"
5313 def MakeTranslationVector(self,theObject, theVector):
5315 Translate the given object along the given vector,
5316 creating its copy before the translation.
5319 theObject The object to be translated.
5320 theVector The translation vector.
5323 New GEOM.GEOM_Object, containing the translated object.
5325 # Example: see GEOM_TestAll.py
5326 anObj = self.TrsfOp.TranslateVectorCopy(theObject, theVector)
5327 RaiseIfFailed("TranslateVectorCopy", self.TrsfOp)
5330 ## Translate the given object along the given vector on given distance.
5331 # @param theObject The object to be translated.
5332 # @param theVector The translation vector.
5333 # @param theDistance The translation distance.
5334 # @param theCopy Flag used to translate object itself or create a copy.
5335 # @return New GEOM.GEOM_Object, containing the translated object.
5337 # @ref tui_translation "Example"
5338 def TranslateVectorDistance(self, theObject, theVector, theDistance, theCopy):
5340 Translate the given object along the given vector on given distance.
5343 theObject The object to be translated.
5344 theVector The translation vector.
5345 theDistance The translation distance.
5346 theCopy Flag used to translate object itself or create a copy.
5349 New GEOM.GEOM_Object, containing the translated object.
5351 # Example: see GEOM_TestAll.py
5352 theDistance,Parameters = ParseParameters(theDistance)
5353 anObj = self.TrsfOp.TranslateVectorDistance(theObject, theVector, theDistance, theCopy)
5354 RaiseIfFailed("TranslateVectorDistance", self.TrsfOp)
5355 anObj.SetParameters(Parameters)
5358 ## Translate the given object along the given vector on given distance,
5359 # creating its copy before the translation.
5360 # @param theObject The object to be translated.
5361 # @param theVector The translation vector.
5362 # @param theDistance The translation distance.
5363 # @return New GEOM.GEOM_Object, containing the translated object.
5365 # @ref tui_translation "Example"
5366 def MakeTranslationVectorDistance(self, theObject, theVector, theDistance):
5368 Translate the given object along the given vector on given distance,
5369 creating its copy before the translation.
5372 theObject The object to be translated.
5373 theVector The translation vector.
5374 theDistance The translation distance.
5377 New GEOM.GEOM_Object, containing the translated object.
5379 # Example: see GEOM_TestAll.py
5380 theDistance,Parameters = ParseParameters(theDistance)
5381 anObj = self.TrsfOp.TranslateVectorDistance(theObject, theVector, theDistance, 1)
5382 RaiseIfFailed("TranslateVectorDistance", self.TrsfOp)
5383 anObj.SetParameters(Parameters)
5386 ## Rotate the given object around the given axis on the given angle.
5387 # @param theObject The object to be rotated.
5388 # @param theAxis Rotation axis.
5389 # @param theAngle Rotation angle in radians.
5390 # @return New GEOM.GEOM_Object, containing the rotated object.
5392 # @ref tui_rotation "Example"
5393 def Rotate(self,theObject, theAxis, theAngle):
5395 Rotate the given object around the given axis on the given angle.
5398 theObject The object to be rotated.
5399 theAxis Rotation axis.
5400 theAngle Rotation angle in radians.
5403 New GEOM.GEOM_Object, containing the rotated object.
5405 # Example: see GEOM_TestAll.py
5407 if isinstance(theAngle,str):
5409 theAngle, Parameters = ParseParameters(theAngle)
5411 theAngle = theAngle*math.pi/180.0
5412 anObj = self.TrsfOp.Rotate(theObject, theAxis, theAngle)
5413 RaiseIfFailed("RotateCopy", self.TrsfOp)
5414 anObj.SetParameters(Parameters)
5417 ## Rotate the given object around the given axis
5418 # on the given angle, creating its copy before the rotatation.
5419 # @param theObject The object to be rotated.
5420 # @param theAxis Rotation axis.
5421 # @param theAngle Rotation angle in radians.
5422 # @return New GEOM.GEOM_Object, containing the rotated object.
5424 # @ref tui_rotation "Example"
5425 def MakeRotation(self,theObject, theAxis, theAngle):
5427 Rotate the given object around the given axis
5428 on the given angle, creating its copy before the rotatation.
5431 theObject The object to be rotated.
5432 theAxis Rotation axis.
5433 theAngle Rotation angle in radians.
5436 New GEOM.GEOM_Object, containing the rotated object.
5438 # Example: see GEOM_TestAll.py
5440 if isinstance(theAngle,str):
5442 theAngle, Parameters = ParseParameters(theAngle)
5444 theAngle = theAngle*math.pi/180.0
5445 anObj = self.TrsfOp.RotateCopy(theObject, theAxis, theAngle)
5446 RaiseIfFailed("RotateCopy", self.TrsfOp)
5447 anObj.SetParameters(Parameters)
5450 ## Rotate given object around vector perpendicular to plane
5451 # containing three points, creating its copy before the rotatation.
5452 # @param theObject The object to be rotated.
5453 # @param theCentPoint central point the axis is the vector perpendicular to the plane
5454 # containing the three points.
5455 # @param thePoint1,thePoint2 in a perpendicular plane of the axis.
5456 # @return New GEOM.GEOM_Object, containing the rotated object.
5458 # @ref tui_rotation "Example"
5459 def MakeRotationThreePoints(self,theObject, theCentPoint, thePoint1, thePoint2):
5461 Rotate given object around vector perpendicular to plane
5462 containing three points, creating its copy before the rotatation.
5465 theObject The object to be rotated.
5466 theCentPoint central point the axis is the vector perpendicular to the plane
5467 containing the three points.
5468 thePoint1,thePoint2 in a perpendicular plane of the axis.
5471 New GEOM.GEOM_Object, containing the rotated object.
5473 # Example: see GEOM_TestAll.py
5474 anObj = self.TrsfOp.RotateThreePointsCopy(theObject, theCentPoint, thePoint1, thePoint2)
5475 RaiseIfFailed("RotateThreePointsCopy", self.TrsfOp)
5478 ## Scale the given object by the factor, creating its copy before the scaling.
5479 # @param theObject The object to be scaled.
5480 # @param thePoint Center point for scaling.
5481 # Passing None for it means scaling relatively the origin of global CS.
5482 # @param theFactor Scaling factor value.
5483 # @return New GEOM.GEOM_Object, containing the scaled shape.
5485 # @ref tui_scale "Example"
5486 def MakeScaleTransform(self, theObject, thePoint, theFactor):
5488 Scale the given object by the factor, creating its copy before the scaling.
5491 theObject The object to be scaled.
5492 thePoint Center point for scaling.
5493 Passing None for it means scaling relatively the origin of global CS.
5494 theFactor Scaling factor value.
5497 New GEOM.GEOM_Object, containing the scaled shape.
5499 # Example: see GEOM_TestAll.py
5500 theFactor, Parameters = ParseParameters(theFactor)
5501 anObj = self.TrsfOp.ScaleShapeCopy(theObject, thePoint, theFactor)
5502 RaiseIfFailed("ScaleShapeCopy", self.TrsfOp)
5503 anObj.SetParameters(Parameters)
5506 ## Scale the given object by different factors along coordinate axes,
5507 # creating its copy before the scaling.
5508 # @param theObject The object to be scaled.
5509 # @param thePoint Center point for scaling.
5510 # Passing None for it means scaling relatively the origin of global CS.
5511 # @param theFactorX,theFactorY,theFactorZ Scaling factors along each axis.
5512 # @return New GEOM.GEOM_Object, containing the scaled shape.
5514 # @ref swig_scale "Example"
5515 def MakeScaleAlongAxes(self, theObject, thePoint, theFactorX, theFactorY, theFactorZ):
5517 Scale the given object by different factors along coordinate axes,
5518 creating its copy before the scaling.
5521 theObject The object to be scaled.
5522 thePoint Center point for scaling.
5523 Passing None for it means scaling relatively the origin of global CS.
5524 theFactorX,theFactorY,theFactorZ Scaling factors along each axis.
5527 New GEOM.GEOM_Object, containing the scaled shape.
5529 # Example: see GEOM_TestAll.py
5530 theFactorX, theFactorY, theFactorZ, Parameters = ParseParameters(theFactorX, theFactorY, theFactorZ)
5531 anObj = self.TrsfOp.ScaleShapeAlongAxesCopy(theObject, thePoint,
5532 theFactorX, theFactorY, theFactorZ)
5533 RaiseIfFailed("MakeScaleAlongAxes", self.TrsfOp)
5534 anObj.SetParameters(Parameters)
5537 ## Create an object, symmetrical
5538 # to the given one relatively the given plane.
5539 # @param theObject The object to be mirrored.
5540 # @param thePlane Plane of symmetry.
5541 # @return New GEOM.GEOM_Object, containing the mirrored shape.
5543 # @ref tui_mirror "Example"
5544 def MakeMirrorByPlane(self,theObject, thePlane):
5546 Create an object, symmetrical to the given one relatively the given plane.
5549 theObject The object to be mirrored.
5550 thePlane Plane of symmetry.
5553 New GEOM.GEOM_Object, containing the mirrored shape.
5555 # Example: see GEOM_TestAll.py
5556 anObj = self.TrsfOp.MirrorPlaneCopy(theObject, thePlane)
5557 RaiseIfFailed("MirrorPlaneCopy", self.TrsfOp)
5560 ## Create an object, symmetrical
5561 # to the given one relatively the given axis.
5562 # @param theObject The object to be mirrored.
5563 # @param theAxis Axis of symmetry.
5564 # @return New GEOM.GEOM_Object, containing the mirrored shape.
5566 # @ref tui_mirror "Example"
5567 def MakeMirrorByAxis(self,theObject, theAxis):
5569 Create an object, symmetrical to the given one relatively the given axis.
5572 theObject The object to be mirrored.
5573 theAxis Axis of symmetry.
5576 New GEOM.GEOM_Object, containing the mirrored shape.
5578 # Example: see GEOM_TestAll.py
5579 anObj = self.TrsfOp.MirrorAxisCopy(theObject, theAxis)
5580 RaiseIfFailed("MirrorAxisCopy", self.TrsfOp)
5583 ## Create an object, symmetrical
5584 # to the given one relatively the given point.
5585 # @param theObject The object to be mirrored.
5586 # @param thePoint Point of symmetry.
5587 # @return New GEOM.GEOM_Object, containing the mirrored shape.
5589 # @ref tui_mirror "Example"
5590 def MakeMirrorByPoint(self,theObject, thePoint):
5592 Create an object, symmetrical
5593 to the given one relatively the given point.
5596 theObject The object to be mirrored.
5597 thePoint Point of symmetry.
5600 New GEOM.GEOM_Object, containing the mirrored shape.
5602 # Example: see GEOM_TestAll.py
5603 anObj = self.TrsfOp.MirrorPointCopy(theObject, thePoint)
5604 RaiseIfFailed("MirrorPointCopy", self.TrsfOp)
5607 ## Modify the Location of the given object by LCS,
5608 # creating its copy before the setting.
5609 # @param theObject The object to be displaced.
5610 # @param theStartLCS Coordinate system to perform displacement from it.\n
5611 # If \a theStartLCS is NULL, displacement
5612 # will be performed from global CS.\n
5613 # If \a theObject itself is used as \a theStartLCS,
5614 # its location will be changed to \a theEndLCS.
5615 # @param theEndLCS Coordinate system to perform displacement to it.
5616 # @return New GEOM.GEOM_Object, containing the displaced shape.
5618 # @ref tui_modify_location "Example"
5619 def MakePosition(self,theObject, theStartLCS, theEndLCS):
5621 Modify the Location of the given object by LCS, creating its copy before the setting.
5624 theObject The object to be displaced.
5625 theStartLCS Coordinate system to perform displacement from it.
5626 If theStartLCS is NULL, displacement
5627 will be performed from global CS.
5628 If theObject itself is used as theStartLCS,
5629 its location will be changed to theEndLCS.
5630 theEndLCS Coordinate system to perform displacement to it.
5633 New GEOM.GEOM_Object, containing the displaced shape.
5636 # create local coordinate systems
5637 cs1 = geompy.MakeMarker( 0, 0, 0, 1,0,0, 0,1,0)
5638 cs2 = geompy.MakeMarker(30,40,40, 1,0,0, 0,1,0)
5639 # modify the location of the given object
5640 position = geompy.MakePosition(cylinder, cs1, cs2)
5642 # Example: see GEOM_TestAll.py
5643 anObj = self.TrsfOp.PositionShapeCopy(theObject, theStartLCS, theEndLCS)
5644 RaiseIfFailed("PositionShapeCopy", self.TrsfOp)
5647 ## Modify the Location of the given object by Path,
5648 # @param theObject The object to be displaced.
5649 # @param thePath Wire or Edge along that the object will be translated.
5650 # @param theDistance progress of Path (0 = start location, 1 = end of path location).
5651 # @param theCopy is to create a copy objects if true.
5652 # @param theReverse 0 - for usual direction, 1 - to reverse path direction.
5653 # @return New GEOM.GEOM_Object, containing the displaced shape.
5655 # @ref tui_modify_location "Example"
5656 def PositionAlongPath(self,theObject, thePath, theDistance, theCopy, theReverse):
5658 Modify the Location of the given object by Path
5661 theObject The object to be displaced.
5662 thePath Wire or Edge along that the object will be translated.
5663 theDistance progress of Path (0 = start location, 1 = end of path location).
5664 theCopy is to create a copy objects if true.
5665 theReverse 0 - for usual direction, 1 - to reverse path direction.
5668 New GEOM.GEOM_Object, containing the displaced shape.
5671 position = geompy.PositionAlongPath(cylinder, circle, 0.75, 1, 1)
5673 # Example: see GEOM_TestAll.py
5674 anObj = self.TrsfOp.PositionAlongPath(theObject, thePath, theDistance, theCopy, theReverse)
5675 RaiseIfFailed("PositionAlongPath", self.TrsfOp)
5678 ## Create new object as offset of the given one.
5679 # @param theObject The base object for the offset.
5680 # @param theOffset Offset value.
5681 # @return New GEOM.GEOM_Object, containing the offset object.
5683 # @ref tui_offset "Example"
5684 def MakeOffset(self,theObject, theOffset):
5686 Create new object as offset of the given one.
5689 theObject The base object for the offset.
5690 theOffset Offset value.
5693 New GEOM.GEOM_Object, containing the offset object.
5696 box = geompy.MakeBox(20, 20, 20, 200, 200, 200)
5697 # create a new object as offset of the given object
5698 offset = geompy.MakeOffset(box, 70.)
5700 # Example: see GEOM_TestAll.py
5701 theOffset, Parameters = ParseParameters(theOffset)
5702 anObj = self.TrsfOp.OffsetShapeCopy(theObject, theOffset)
5703 RaiseIfFailed("OffsetShapeCopy", self.TrsfOp)
5704 anObj.SetParameters(Parameters)
5707 ## Create new object as projection of the given one on a 2D surface.
5708 # @param theSource The source object for the projection. It can be a point, edge or wire.
5709 # @param theTarget The target object. It can be planar or cylindrical face.
5710 # @return New GEOM.GEOM_Object, containing the projection.
5712 # @ref tui_projection "Example"
5713 def MakeProjection(self, theSource, theTarget):
5715 Create new object as projection of the given one on a 2D surface.
5718 theSource The source object for the projection. It can be a point, edge or wire.
5719 theTarget The target object. It can be planar or cylindrical face.
5722 New GEOM.GEOM_Object, containing the projection.
5724 # Example: see GEOM_TestAll.py
5725 anObj = self.TrsfOp.ProjectShapeCopy(theSource, theTarget)
5726 RaiseIfFailed("ProjectShapeCopy", self.TrsfOp)
5729 # -----------------------------------------------------------------------------
5731 # -----------------------------------------------------------------------------
5733 ## Translate the given object along the given vector a given number times
5734 # @param theObject The object to be translated.
5735 # @param theVector Direction of the translation.
5736 # @param theStep Distance to translate on.
5737 # @param theNbTimes Quantity of translations to be done.
5738 # @return New GEOM.GEOM_Object, containing compound of all
5739 # the shapes, obtained after each translation.
5741 # @ref tui_multi_translation "Example"
5742 def MakeMultiTranslation1D(self,theObject, theVector, theStep, theNbTimes):
5744 Translate the given object along the given vector a given number times
5747 theObject The object to be translated.
5748 theVector Direction of the translation.
5749 theStep Distance to translate on.
5750 theNbTimes Quantity of translations to be done.
5753 New GEOM.GEOM_Object, containing compound of all
5754 the shapes, obtained after each translation.
5757 r1d = geompy.MakeMultiTranslation1D(prism, vect, 20, 4)
5759 # Example: see GEOM_TestAll.py
5760 theStep, theNbTimes, Parameters = ParseParameters(theStep, theNbTimes)
5761 anObj = self.TrsfOp.MultiTranslate1D(theObject, theVector, theStep, theNbTimes)
5762 RaiseIfFailed("MultiTranslate1D", self.TrsfOp)
5763 anObj.SetParameters(Parameters)
5766 ## Conseqently apply two specified translations to theObject specified number of times.
5767 # @param theObject The object to be translated.
5768 # @param theVector1 Direction of the first translation.
5769 # @param theStep1 Step of the first translation.
5770 # @param theNbTimes1 Quantity of translations to be done along theVector1.
5771 # @param theVector2 Direction of the second translation.
5772 # @param theStep2 Step of the second translation.
5773 # @param theNbTimes2 Quantity of translations to be done along theVector2.
5774 # @return New GEOM.GEOM_Object, containing compound of all
5775 # the shapes, obtained after each translation.
5777 # @ref tui_multi_translation "Example"
5778 def MakeMultiTranslation2D(self,theObject, theVector1, theStep1, theNbTimes1,
5779 theVector2, theStep2, theNbTimes2):
5781 Conseqently apply two specified translations to theObject specified number of times.
5784 theObject The object to be translated.
5785 theVector1 Direction of the first translation.
5786 theStep1 Step of the first translation.
5787 theNbTimes1 Quantity of translations to be done along theVector1.
5788 theVector2 Direction of the second translation.
5789 theStep2 Step of the second translation.
5790 theNbTimes2 Quantity of translations to be done along theVector2.
5793 New GEOM.GEOM_Object, containing compound of all
5794 the shapes, obtained after each translation.
5797 tr2d = geompy.MakeMultiTranslation2D(prism, vect1, 20, 4, vect2, 80, 3)
5799 # Example: see GEOM_TestAll.py
5800 theStep1,theNbTimes1,theStep2,theNbTimes2, Parameters = ParseParameters(theStep1,theNbTimes1,theStep2,theNbTimes2)
5801 anObj = self.TrsfOp.MultiTranslate2D(theObject, theVector1, theStep1, theNbTimes1,
5802 theVector2, theStep2, theNbTimes2)
5803 RaiseIfFailed("MultiTranslate2D", self.TrsfOp)
5804 anObj.SetParameters(Parameters)
5807 ## Rotate the given object around the given axis a given number times.
5808 # Rotation angle will be 2*PI/theNbTimes.
5809 # @param theObject The object to be rotated.
5810 # @param theAxis The rotation axis.
5811 # @param theNbTimes Quantity of rotations to be done.
5812 # @return New GEOM.GEOM_Object, containing compound of all the
5813 # shapes, obtained after each rotation.
5815 # @ref tui_multi_rotation "Example"
5816 def MultiRotate1D(self,theObject, theAxis, theNbTimes):
5818 Rotate the given object around the given axis a given number times.
5819 Rotation angle will be 2*PI/theNbTimes.
5822 theObject The object to be rotated.
5823 theAxis The rotation axis.
5824 theNbTimes Quantity of rotations to be done.
5827 New GEOM.GEOM_Object, containing compound of all the
5828 shapes, obtained after each rotation.
5831 rot1d = geompy.MultiRotate1D(prism, vect, 4)
5833 # Example: see GEOM_TestAll.py
5834 theAxis, theNbTimes, Parameters = ParseParameters(theAxis, theNbTimes)
5835 anObj = self.TrsfOp.MultiRotate1D(theObject, theAxis, theNbTimes)
5836 RaiseIfFailed("MultiRotate1D", self.TrsfOp)
5837 anObj.SetParameters(Parameters)
5840 ## Rotate the given object around the
5841 # given axis on the given angle a given number
5842 # times and multi-translate each rotation result.
5843 # Translation direction passes through center of gravity
5844 # of rotated shape and its projection on the rotation axis.
5845 # @param theObject The object to be rotated.
5846 # @param theAxis Rotation axis.
5847 # @param theAngle Rotation angle in graduces.
5848 # @param theNbTimes1 Quantity of rotations to be done.
5849 # @param theStep Translation distance.
5850 # @param theNbTimes2 Quantity of translations to be done.
5851 # @return New GEOM.GEOM_Object, containing compound of all the
5852 # shapes, obtained after each transformation.
5854 # @ref tui_multi_rotation "Example"
5855 def MultiRotate2D(self,theObject, theAxis, theAngle, theNbTimes1, theStep, theNbTimes2):
5857 Rotate the given object around the
5858 given axis on the given angle a given number
5859 times and multi-translate each rotation result.
5860 Translation direction passes through center of gravity
5861 of rotated shape and its projection on the rotation axis.
5864 theObject The object to be rotated.
5865 theAxis Rotation axis.
5866 theAngle Rotation angle in graduces.
5867 theNbTimes1 Quantity of rotations to be done.
5868 theStep Translation distance.
5869 theNbTimes2 Quantity of translations to be done.
5872 New GEOM.GEOM_Object, containing compound of all the
5873 shapes, obtained after each transformation.
5876 rot2d = geompy.MultiRotate2D(prism, vect, 60, 4, 50, 5)
5878 # Example: see GEOM_TestAll.py
5879 theAngle, theNbTimes1, theStep, theNbTimes2, Parameters = ParseParameters(theAngle, theNbTimes1, theStep, theNbTimes2)
5880 anObj = self.TrsfOp.MultiRotate2D(theObject, theAxis, theAngle, theNbTimes1, theStep, theNbTimes2)
5881 RaiseIfFailed("MultiRotate2D", self.TrsfOp)
5882 anObj.SetParameters(Parameters)
5885 ## The same, as MultiRotate1D(), but axis is given by direction and point
5887 # @ref swig_MakeMultiRotation "Example"
5888 def MakeMultiRotation1D(self,aShape,aDir,aPoint,aNbTimes):
5890 The same, as geompy.MultiRotate1D, but axis is given by direction and point
5893 pz = geompy.MakeVertex(0, 0, 100)
5894 vy = geompy.MakeVectorDXDYDZ(0, 100, 0)
5895 MultiRot1D = geompy.MakeMultiRotation1D(prism, vy, pz, 6)
5897 # Example: see GEOM_TestOthers.py
5898 aVec = self.MakeLine(aPoint,aDir)
5899 anObj = self.MultiRotate1D(aShape,aVec,aNbTimes)
5902 ## The same, as MultiRotate2D(), but axis is given by direction and point
5904 # @ref swig_MakeMultiRotation "Example"
5905 def MakeMultiRotation2D(self,aShape,aDir,aPoint,anAngle,nbtimes1,aStep,nbtimes2):
5907 The same, as MultiRotate2D(), but axis is given by direction and point
5910 pz = geompy.MakeVertex(0, 0, 100)
5911 vy = geompy.MakeVectorDXDYDZ(0, 100, 0)
5912 MultiRot2D = geompy.MakeMultiRotation2D(f12, vy, pz, 45, 6, 30, 3)
5914 # Example: see GEOM_TestOthers.py
5915 aVec = self.MakeLine(aPoint,aDir)
5916 anObj = self.MultiRotate2D(aShape,aVec,anAngle,nbtimes1,aStep,nbtimes2)
5919 # end of l3_transform
5922 ## @addtogroup l3_local
5925 ## Perform a fillet on all edges of the given shape.
5926 # @param theShape Shape, to perform fillet on.
5927 # @param theR Fillet radius.
5928 # @return New GEOM.GEOM_Object, containing the result shape.
5930 # @ref tui_fillet "Example 1"
5931 # \n @ref swig_MakeFilletAll "Example 2"
5932 def MakeFilletAll(self,theShape, theR):
5934 Perform a fillet on all edges of the given shape.
5937 theShape Shape, to perform fillet on.
5941 New GEOM.GEOM_Object, containing the result shape.
5944 filletall = geompy.MakeFilletAll(prism, 10.)
5946 # Example: see GEOM_TestOthers.py
5947 theR,Parameters = ParseParameters(theR)
5948 anObj = self.LocalOp.MakeFilletAll(theShape, theR)
5949 RaiseIfFailed("MakeFilletAll", self.LocalOp)
5950 anObj.SetParameters(Parameters)
5953 ## Perform a fillet on the specified edges/faces of the given shape
5954 # @param theShape Shape, to perform fillet on.
5955 # @param theR Fillet radius.
5956 # @param theShapeType Type of shapes in <VAR>theListShapes</VAR> (see ShapeType())
5957 # @param theListShapes Global indices of edges/faces to perform fillet on.
5958 # \note Global index of sub-shape can be obtained, using method GetSubShapeID().
5959 # @return New GEOM.GEOM_Object, containing the result shape.
5961 # @ref tui_fillet "Example"
5962 def MakeFillet(self,theShape, theR, theShapeType, theListShapes):
5964 Perform a fillet on the specified edges/faces of the given shape
5967 theShape Shape, to perform fillet on.
5969 theShapeType Type of shapes in theListShapes (see geompy.ShapeTypes)
5970 theListShapes Global indices of edges/faces to perform fillet on.
5973 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
5976 New GEOM.GEOM_Object, containing the result shape.
5979 # get the list of IDs (IDList) for the fillet
5980 prism_edges = geompy.SubShapeAllSortedCentres(prism, geompy.ShapeType["EDGE"])
5982 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[0]))
5983 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[1]))
5984 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[2]))
5985 # make a fillet on the specified edges of the given shape
5986 fillet = geompy.MakeFillet(prism, 10., geompy.ShapeType["EDGE"], IDlist_e)
5988 # Example: see GEOM_TestAll.py
5989 theR,Parameters = ParseParameters(theR)
5991 if theShapeType == ShapeType["EDGE"]:
5992 anObj = self.LocalOp.MakeFilletEdges(theShape, theR, theListShapes)
5993 RaiseIfFailed("MakeFilletEdges", self.LocalOp)
5995 anObj = self.LocalOp.MakeFilletFaces(theShape, theR, theListShapes)
5996 RaiseIfFailed("MakeFilletFaces", self.LocalOp)
5997 anObj.SetParameters(Parameters)
6000 ## The same that MakeFillet() but with two Fillet Radius R1 and R2
6001 def MakeFilletR1R2(self, theShape, theR1, theR2, theShapeType, theListShapes):
6003 The same that geompy.MakeFillet but with two Fillet Radius R1 and R2
6006 # get the list of IDs (IDList) for the fillet
6007 prism_edges = geompy.SubShapeAllSortedCentres(prism, geompy.ShapeType["EDGE"])
6009 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[0]))
6010 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[1]))
6011 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[2]))
6012 # make a fillet on the specified edges of the given shape
6013 fillet = geompy.MakeFillet(prism, 10., 15., geompy.ShapeType["EDGE"], IDlist_e)
6015 theR1,theR2,Parameters = ParseParameters(theR1,theR2)
6017 if theShapeType == ShapeType["EDGE"]:
6018 anObj = self.LocalOp.MakeFilletEdgesR1R2(theShape, theR1, theR2, theListShapes)
6019 RaiseIfFailed("MakeFilletEdgesR1R2", self.LocalOp)
6021 anObj = self.LocalOp.MakeFilletFacesR1R2(theShape, theR1, theR2, theListShapes)
6022 RaiseIfFailed("MakeFilletFacesR1R2", self.LocalOp)
6023 anObj.SetParameters(Parameters)
6026 ## Perform a fillet on the specified edges of the given shape
6027 # @param theShape Wire Shape to perform fillet on.
6028 # @param theR Fillet radius.
6029 # @param theListOfVertexes Global indices of vertexes to perform fillet on.
6030 # \note Global index of sub-shape can be obtained, using method GetSubShapeID()
6031 # \note The list of vertices could be empty,
6032 # in this case fillet will done done at all vertices in wire
6033 # @param doIgnoreSecantVertices If FALSE, fillet radius is always limited
6034 # by the length of the edges, nearest to the fillet vertex.
6035 # But sometimes the next edge is C1 continuous with the one, nearest to
6036 # the fillet point, and such two (or more) edges can be united to allow
6037 # bigger radius. Set this flag to TRUE to allow collinear edges union,
6038 # thus ignoring the secant vertex (vertices).
6039 # @return New GEOM.GEOM_Object, containing the result shape.
6041 # @ref tui_fillet2d "Example"
6042 def MakeFillet1D(self,theShape, theR, theListOfVertexes, doIgnoreSecantVertices = True):
6044 Perform a fillet on the specified edges of the given shape
6047 theShape Wire Shape to perform fillet on.
6049 theListOfVertexes Global indices of vertexes to perform fillet on.
6050 doIgnoreSecantVertices If FALSE, fillet radius is always limited
6051 by the length of the edges, nearest to the fillet vertex.
6052 But sometimes the next edge is C1 continuous with the one, nearest to
6053 the fillet point, and such two (or more) edges can be united to allow
6054 bigger radius. Set this flag to TRUE to allow collinear edges union,
6055 thus ignoring the secant vertex (vertices).
6057 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
6059 The list of vertices could be empty,in this case fillet will done done at all vertices in wire
6062 New GEOM.GEOM_Object, containing the result shape.
6066 Wire_1 = geompy.MakeWire([Edge_12, Edge_7, Edge_11, Edge_6, Edge_1,Edge_4])
6067 # make fillet at given wire vertices with giver radius
6068 Fillet_1D_1 = geompy.MakeFillet1D(Wire_1, 55, [3, 4, 6, 8, 10])
6070 # Example: see GEOM_TestAll.py
6071 theR,doIgnoreSecantVertices,Parameters = ParseParameters(theR,doIgnoreSecantVertices)
6072 anObj = self.LocalOp.MakeFillet1D(theShape, theR, theListOfVertexes, doIgnoreSecantVertices)
6073 RaiseIfFailed("MakeFillet1D", self.LocalOp)
6074 anObj.SetParameters(Parameters)
6077 ## Perform a fillet at the specified vertices of the given face/shell.
6078 # @param theShape Face or Shell shape to perform fillet on.
6079 # @param theR Fillet radius.
6080 # @param theListOfVertexes Global indices of vertexes to perform fillet on.
6081 # \note Global index of sub-shape can be obtained, using method GetSubShapeID().
6082 # @return New GEOM.GEOM_Object, containing the result shape.
6084 # @ref tui_fillet2d "Example"
6085 def MakeFillet2D(self, theShape, theR, theListOfVertexes):
6087 Perform a fillet at the specified vertices of the given face/shell.
6090 theShape Face or Shell shape to perform fillet on.
6092 theListOfVertexes Global indices of vertexes to perform fillet on.
6094 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
6097 New GEOM.GEOM_Object, containing the result shape.
6100 face = geompy.MakeFaceHW(100, 100, 1)
6101 fillet2d = geompy.MakeFillet2D(face, 30, [7, 9])
6103 # Example: see GEOM_TestAll.py
6104 theR,Parameters = ParseParameters(theR)
6105 anObj = self.LocalOp.MakeFillet2D(theShape, theR, theListOfVertexes)
6106 RaiseIfFailed("MakeFillet2D", self.LocalOp)
6107 anObj.SetParameters(Parameters)
6110 ## Perform a symmetric chamfer on all edges of the given shape.
6111 # @param theShape Shape, to perform chamfer on.
6112 # @param theD Chamfer size along each face.
6113 # @return New GEOM.GEOM_Object, containing the result shape.
6115 # @ref tui_chamfer "Example 1"
6116 # \n @ref swig_MakeChamferAll "Example 2"
6117 def MakeChamferAll(self,theShape, theD):
6119 Perform a symmetric chamfer on all edges of the given shape.
6122 theShape Shape, to perform chamfer on.
6123 theD Chamfer size along each face.
6126 New GEOM.GEOM_Object, containing the result shape.
6129 chamfer_all = geompy.MakeChamferAll(prism, 10.)
6131 # Example: see GEOM_TestOthers.py
6132 theD,Parameters = ParseParameters(theD)
6133 anObj = self.LocalOp.MakeChamferAll(theShape, theD)
6134 RaiseIfFailed("MakeChamferAll", self.LocalOp)
6135 anObj.SetParameters(Parameters)
6138 ## Perform a chamfer on edges, common to the specified faces,
6139 # with distance D1 on the Face1
6140 # @param theShape Shape, to perform chamfer on.
6141 # @param theD1 Chamfer size along \a theFace1.
6142 # @param theD2 Chamfer size along \a theFace2.
6143 # @param theFace1,theFace2 Global indices of two faces of \a theShape.
6144 # \note Global index of sub-shape can be obtained, using method GetSubShapeID().
6145 # @return New GEOM.GEOM_Object, containing the result shape.
6147 # @ref tui_chamfer "Example"
6148 def MakeChamferEdge(self,theShape, theD1, theD2, theFace1, theFace2):
6150 Perform a chamfer on edges, common to the specified faces,
6151 with distance D1 on the Face1
6154 theShape Shape, to perform chamfer on.
6155 theD1 Chamfer size along theFace1.
6156 theD2 Chamfer size along theFace2.
6157 theFace1,theFace2 Global indices of two faces of theShape.
6160 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
6163 New GEOM.GEOM_Object, containing the result shape.
6166 prism_faces = geompy.SubShapeAllSortedCentres(prism, geompy.ShapeType["FACE"])
6167 f_ind_1 = geompy.GetSubShapeID(prism, prism_faces[0])
6168 f_ind_2 = geompy.GetSubShapeID(prism, prism_faces[1])
6169 chamfer_e = geompy.MakeChamferEdge(prism, 10., 10., f_ind_1, f_ind_2)
6171 # Example: see GEOM_TestAll.py
6172 theD1,theD2,Parameters = ParseParameters(theD1,theD2)
6173 anObj = self.LocalOp.MakeChamferEdge(theShape, theD1, theD2, theFace1, theFace2)
6174 RaiseIfFailed("MakeChamferEdge", self.LocalOp)
6175 anObj.SetParameters(Parameters)
6178 ## Perform a chamfer on edges
6179 # @param theShape Shape, to perform chamfer on.
6180 # @param theD Chamfer length
6181 # @param theAngle Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
6182 # @param theFace1,theFace2 Global indices of two faces of \a theShape.
6183 # \note Global index of sub-shape can be obtained, using method GetSubShapeID().
6184 # @return New GEOM.GEOM_Object, containing the result shape.
6185 def MakeChamferEdgeAD(self, theShape, theD, theAngle, theFace1, theFace2):
6187 Perform a chamfer on edges
6190 theShape Shape, to perform chamfer on.
6191 theD1 Chamfer size along theFace1.
6192 theAngle Angle of chamfer (angle in radians or a name of variable which defines angle in degrees).
6193 theFace1,theFace2 Global indices of two faces of theShape.
6196 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
6199 New GEOM.GEOM_Object, containing the result shape.
6202 prism_faces = geompy.SubShapeAllSortedCentres(prism, geompy.ShapeType["FACE"])
6203 f_ind_1 = geompy.GetSubShapeID(prism, prism_faces[0])
6204 f_ind_2 = geompy.GetSubShapeID(prism, prism_faces[1])
6206 chamfer_e = geompy.MakeChamferEdge(prism, 10., ang, f_ind_1, f_ind_2)
6209 if isinstance(theAngle,str):
6211 theD,theAngle,Parameters = ParseParameters(theD,theAngle)
6213 theAngle = theAngle*math.pi/180.0
6214 anObj = self.LocalOp.MakeChamferEdgeAD(theShape, theD, theAngle, theFace1, theFace2)
6215 RaiseIfFailed("MakeChamferEdgeAD", self.LocalOp)
6216 anObj.SetParameters(Parameters)
6219 ## Perform a chamfer on all edges of the specified faces,
6220 # with distance D1 on the first specified face (if several for one edge)
6221 # @param theShape Shape, to perform chamfer on.
6222 # @param theD1 Chamfer size along face from \a theFaces. If both faces,
6223 # connected to the edge, are in \a theFaces, \a theD1
6224 # will be get along face, which is nearer to \a theFaces beginning.
6225 # @param theD2 Chamfer size along another of two faces, connected to the edge.
6226 # @param theFaces Sequence of global indices of faces of \a theShape.
6227 # \note Global index of sub-shape can be obtained, using method GetSubShapeID().
6228 # @return New GEOM.GEOM_Object, containing the result shape.
6230 # @ref tui_chamfer "Example"
6231 def MakeChamferFaces(self,theShape, theD1, theD2, theFaces):
6233 Perform a chamfer on all edges of the specified faces,
6234 with distance D1 on the first specified face (if several for one edge)
6237 theShape Shape, to perform chamfer on.
6238 theD1 Chamfer size along face from theFaces. If both faces,
6239 connected to the edge, are in theFaces, theD1
6240 will be get along face, which is nearer to theFaces beginning.
6241 theD2 Chamfer size along another of two faces, connected to the edge.
6242 theFaces Sequence of global indices of faces of theShape.
6245 Note: Global index of sub-shape can be obtained, using method geompy.GetSubShapeID().
6248 New GEOM.GEOM_Object, containing the result shape.
6250 # Example: see GEOM_TestAll.py
6251 theD1,theD2,Parameters = ParseParameters(theD1,theD2)
6252 anObj = self.LocalOp.MakeChamferFaces(theShape, theD1, theD2, theFaces)
6253 RaiseIfFailed("MakeChamferFaces", self.LocalOp)
6254 anObj.SetParameters(Parameters)
6257 ## The Same that MakeChamferFaces() but with params theD is chamfer lenght and
6258 # theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
6260 # @ref swig_FilletChamfer "Example"
6261 def MakeChamferFacesAD(self, theShape, theD, theAngle, theFaces):
6263 The Same that geompy.MakeChamferFaces but with params theD is chamfer lenght and
6264 theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
6267 if isinstance(theAngle,str):
6269 theD,theAngle,Parameters = ParseParameters(theD,theAngle)
6271 theAngle = theAngle*math.pi/180.0
6272 anObj = self.LocalOp.MakeChamferFacesAD(theShape, theD, theAngle, theFaces)
6273 RaiseIfFailed("MakeChamferFacesAD", self.LocalOp)
6274 anObj.SetParameters(Parameters)
6277 ## Perform a chamfer on edges,
6278 # with distance D1 on the first specified face (if several for one edge)
6279 # @param theShape Shape, to perform chamfer on.
6280 # @param theD1,theD2 Chamfer size
6281 # @param theEdges Sequence of edges of \a theShape.
6282 # @return New GEOM.GEOM_Object, containing the result shape.
6284 # @ref swig_FilletChamfer "Example"
6285 def MakeChamferEdges(self, theShape, theD1, theD2, theEdges):
6287 Perform a chamfer on edges,
6288 with distance D1 on the first specified face (if several for one edge)
6291 theShape Shape, to perform chamfer on.
6292 theD1,theD2 Chamfer size
6293 theEdges Sequence of edges of theShape.
6296 New GEOM.GEOM_Object, containing the result shape.
6298 theD1,theD2,Parameters = ParseParameters(theD1,theD2)
6299 anObj = self.LocalOp.MakeChamferEdges(theShape, theD1, theD2, theEdges)
6300 RaiseIfFailed("MakeChamferEdges", self.LocalOp)
6301 anObj.SetParameters(Parameters)
6304 ## The Same that MakeChamferEdges() but with params theD is chamfer lenght and
6305 # theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
6306 def MakeChamferEdgesAD(self, theShape, theD, theAngle, theEdges):
6308 The Same that geompy.MakeChamferEdges but with params theD is chamfer lenght and
6309 theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
6312 if isinstance(theAngle,str):
6314 theD,theAngle,Parameters = ParseParameters(theD,theAngle)
6316 theAngle = theAngle*math.pi/180.0
6317 anObj = self.LocalOp.MakeChamferEdgesAD(theShape, theD, theAngle, theEdges)
6318 RaiseIfFailed("MakeChamferEdgesAD", self.LocalOp)
6319 anObj.SetParameters(Parameters)
6322 ## /sa MakeChamferEdge() and MakeChamferFaces()
6324 # @ref swig_MakeChamfer "Example"
6325 def MakeChamfer(self,aShape,d1,d2,aShapeType,ListShape):
6327 See geompy.MakeChamferEdge() and geompy.MakeChamferFaces() functions for more information.
6329 # Example: see GEOM_TestOthers.py
6331 if aShapeType == ShapeType["EDGE"]:
6332 anObj = self.MakeChamferEdge(aShape,d1,d2,ListShape[0],ListShape[1])
6334 anObj = self.MakeChamferFaces(aShape,d1,d2,ListShape)
6337 ## Remove material from a solid by extrusion of the base shape on the given distance.
6338 # @param theInit Shape to remove material from. It must be a solid or
6339 # a compound made of a single solid.
6340 # @param theBase Closed edge or wire defining the base shape to be extruded.
6341 # @param theH Prism dimension along the normal to theBase
6342 # @param theAngle Draft angle in degrees.
6343 # @return New GEOM.GEOM_Object, containing the initial shape with removed material
6345 # @ref tui_creation_prism "Example"
6346 def MakeExtrudedCut(self, theInit, theBase, theH, theAngle):
6348 Add material to a solid by extrusion of the base shape on the given distance.
6351 theInit Shape to remove material from. It must be a solid or a compound made of a single solid.
6352 theBase Closed edge or wire defining the base shape to be extruded.
6353 theH Prism dimension along the normal to theBase
6354 theAngle Draft angle in degrees.
6357 New GEOM.GEOM_Object, containing the initial shape with removed material.
6359 # Example: see GEOM_TestAll.py
6360 #theH,Parameters = ParseParameters(theH)
6361 anObj = self.PrimOp.MakeDraftPrism(theInit, theBase, theH, theAngle, False)
6362 RaiseIfFailed("MakeExtrudedBoss", self.PrimOp)
6363 #anObj.SetParameters(Parameters)
6366 ## Add material to a solid by extrusion of the base shape on the given distance.
6367 # @param theInit Shape to add material to. It must be a solid or
6368 # a compound made of a single solid.
6369 # @param theBase Closed edge or wire defining the base shape to be extruded.
6370 # @param theH Prism dimension along the normal to theBase
6371 # @param theAngle Draft angle in degrees.
6372 # @return New GEOM.GEOM_Object, containing the initial shape with added material
6374 # @ref tui_creation_prism "Example"
6375 def MakeExtrudedBoss(self, theInit, theBase, theH, theAngle):
6377 Add material to a solid by extrusion of the base shape on the given distance.
6380 theInit Shape to add material to. It must be a solid or a compound made of a single solid.
6381 theBase Closed edge or wire defining the base shape to be extruded.
6382 theH Prism dimension along the normal to theBase
6383 theAngle Draft angle in degrees.
6386 New GEOM.GEOM_Object, containing the initial shape with added material.
6388 # Example: see GEOM_TestAll.py
6389 #theH,Parameters = ParseParameters(theH)
6390 anObj = self.PrimOp.MakeDraftPrism(theInit, theBase, theH, theAngle, True)
6391 RaiseIfFailed("MakeExtrudedBoss", self.PrimOp)
6392 #anObj.SetParameters(Parameters)
6398 ## @addtogroup l3_basic_op
6401 ## Perform an Archimde operation on the given shape with given parameters.
6402 # The object presenting the resulting face is returned.
6403 # @param theShape Shape to be put in water.
6404 # @param theWeight Weight og the shape.
6405 # @param theWaterDensity Density of the water.
6406 # @param theMeshDeflection Deflection of the mesh, using to compute the section.
6407 # @return New GEOM.GEOM_Object, containing a section of \a theShape
6408 # by a plane, corresponding to water level.
6410 # @ref tui_archimede "Example"
6411 def Archimede(self,theShape, theWeight, theWaterDensity, theMeshDeflection):
6413 Perform an Archimde operation on the given shape with given parameters.
6414 The object presenting the resulting face is returned.
6417 theShape Shape to be put in water.
6418 theWeight Weight og the shape.
6419 theWaterDensity Density of the water.
6420 theMeshDeflection Deflection of the mesh, using to compute the section.
6423 New GEOM.GEOM_Object, containing a section of theShape
6424 by a plane, corresponding to water level.
6426 # Example: see GEOM_TestAll.py
6427 theWeight,theWaterDensity,theMeshDeflection,Parameters = ParseParameters(
6428 theWeight,theWaterDensity,theMeshDeflection)
6429 anObj = self.LocalOp.MakeArchimede(theShape, theWeight, theWaterDensity, theMeshDeflection)
6430 RaiseIfFailed("MakeArchimede", self.LocalOp)
6431 anObj.SetParameters(Parameters)
6434 # end of l3_basic_op
6437 ## @addtogroup l2_measure
6440 ## Get point coordinates
6443 # @ref tui_measurement_tools_page "Example"
6444 def PointCoordinates(self,Point):
6446 Get point coordinates
6451 # Example: see GEOM_TestMeasures.py
6452 aTuple = self.MeasuOp.PointCoordinates(Point)
6453 RaiseIfFailed("PointCoordinates", self.MeasuOp)
6456 ## Get summarized length of all wires,
6457 # area of surface and volume of the given shape.
6458 # @param theShape Shape to define properties of.
6459 # @return [theLength, theSurfArea, theVolume]\n
6460 # theLength: Summarized length of all wires of the given shape.\n
6461 # theSurfArea: Area of surface of the given shape.\n
6462 # theVolume: Volume of the given shape.
6464 # @ref tui_measurement_tools_page "Example"
6465 def BasicProperties(self,theShape):
6467 Get summarized length of all wires,
6468 area of surface and volume of the given shape.
6471 theShape Shape to define properties of.
6474 [theLength, theSurfArea, theVolume]
6475 theLength: Summarized length of all wires of the given shape.
6476 theSurfArea: Area of surface of the given shape.
6477 theVolume: Volume of the given shape.
6479 # Example: see GEOM_TestMeasures.py
6480 aTuple = self.MeasuOp.GetBasicProperties(theShape)
6481 RaiseIfFailed("GetBasicProperties", self.MeasuOp)
6484 ## Get parameters of bounding box of the given shape
6485 # @param theShape Shape to obtain bounding box of.
6486 # @return [Xmin,Xmax, Ymin,Ymax, Zmin,Zmax]
6487 # Xmin,Xmax: Limits of shape along OX axis.
6488 # Ymin,Ymax: Limits of shape along OY axis.
6489 # Zmin,Zmax: Limits of shape along OZ axis.
6491 # @ref tui_measurement_tools_page "Example"
6492 def BoundingBox(self,theShape):
6494 Get parameters of bounding box of the given shape
6497 theShape Shape to obtain bounding box of.
6500 [Xmin,Xmax, Ymin,Ymax, Zmin,Zmax]
6501 Xmin,Xmax: Limits of shape along OX axis.
6502 Ymin,Ymax: Limits of shape along OY axis.
6503 Zmin,Zmax: Limits of shape along OZ axis.
6505 # Example: see GEOM_TestMeasures.py
6506 aTuple = self.MeasuOp.GetBoundingBox(theShape)
6507 RaiseIfFailed("GetBoundingBox", self.MeasuOp)
6510 ## Get inertia matrix and moments of inertia of theShape.
6511 # @param theShape Shape to calculate inertia of.
6512 # @return [I11,I12,I13, I21,I22,I23, I31,I32,I33, Ix,Iy,Iz]
6513 # I(1-3)(1-3): Components of the inertia matrix of the given shape.
6514 # Ix,Iy,Iz: Moments of inertia of the given shape.
6516 # @ref tui_measurement_tools_page "Example"
6517 def Inertia(self,theShape):
6519 Get inertia matrix and moments of inertia of theShape.
6522 theShape Shape to calculate inertia of.
6525 [I11,I12,I13, I21,I22,I23, I31,I32,I33, Ix,Iy,Iz]
6526 I(1-3)(1-3): Components of the inertia matrix of the given shape.
6527 Ix,Iy,Iz: Moments of inertia of the given shape.
6529 # Example: see GEOM_TestMeasures.py
6530 aTuple = self.MeasuOp.GetInertia(theShape)
6531 RaiseIfFailed("GetInertia", self.MeasuOp)
6534 ## Get if coords are included in the shape (ST_IN or ST_ON)
6535 # @param theShape Shape
6536 # @param coords list of points coordinates [x1, y1, z1, x2, y2, z2, ...]
6537 # @param tolerance to be used (default is 1.0e-7)
6538 # @return list_of_boolean = [res1, res2, ...]
6539 def AreCoordsInside(self, theShape, coords, tolerance=1.e-7):
6541 Get if coords are included in the shape (ST_IN or ST_ON)
6545 coords list of points coordinates [x1, y1, z1, x2, y2, z2, ...]
6546 tolerance to be used (default is 1.0e-7)
6549 list_of_boolean = [res1, res2, ...]
6551 return self.MeasuOp.AreCoordsInside(theShape, coords, tolerance)
6553 ## Get minimal distance between the given shapes.
6554 # @param theShape1,theShape2 Shapes to find minimal distance between.
6555 # @return Value of the minimal distance between the given shapes.
6557 # @ref tui_measurement_tools_page "Example"
6558 def MinDistance(self, theShape1, theShape2):
6560 Get minimal distance between the given shapes.
6563 theShape1,theShape2 Shapes to find minimal distance between.
6566 Value of the minimal distance between the given shapes.
6568 # Example: see GEOM_TestMeasures.py
6569 aTuple = self.MeasuOp.GetMinDistance(theShape1, theShape2)
6570 RaiseIfFailed("GetMinDistance", self.MeasuOp)
6573 ## Get minimal distance between the given shapes.
6574 # @param theShape1,theShape2 Shapes to find minimal distance between.
6575 # @return Value of the minimal distance between the given shapes.
6577 # @ref swig_all_measure "Example"
6578 def MinDistanceComponents(self, theShape1, theShape2):
6580 Get minimal distance between the given shapes.
6583 theShape1,theShape2 Shapes to find minimal distance between.
6586 Value of the minimal distance between the given shapes.
6588 # Example: see GEOM_TestMeasures.py
6589 aTuple = self.MeasuOp.GetMinDistance(theShape1, theShape2)
6590 RaiseIfFailed("GetMinDistance", self.MeasuOp)
6591 aRes = [aTuple[0], aTuple[4] - aTuple[1], aTuple[5] - aTuple[2], aTuple[6] - aTuple[3]]
6594 ## Get angle between the given shapes in degrees.
6595 # @param theShape1,theShape2 Lines or linear edges to find angle between.
6596 # @note If both arguments are vectors, the angle is computed in accordance
6597 # with their orientations, otherwise the minimum angle is computed.
6598 # @return Value of the angle between the given shapes in degrees.
6600 # @ref tui_measurement_tools_page "Example"
6601 def GetAngle(self, theShape1, theShape2):
6603 Get angle between the given shapes in degrees.
6606 theShape1,theShape2 Lines or linear edges to find angle between.
6609 If both arguments are vectors, the angle is computed in accordance
6610 with their orientations, otherwise the minimum angle is computed.
6613 Value of the angle between the given shapes in degrees.
6615 # Example: see GEOM_TestMeasures.py
6616 anAngle = self.MeasuOp.GetAngle(theShape1, theShape2)
6617 RaiseIfFailed("GetAngle", self.MeasuOp)
6620 ## Get angle between the given shapes in radians.
6621 # @param theShape1,theShape2 Lines or linear edges to find angle between.
6622 # @note If both arguments are vectors, the angle is computed in accordance
6623 # with their orientations, otherwise the minimum angle is computed.
6624 # @return Value of the angle between the given shapes in radians.
6626 # @ref tui_measurement_tools_page "Example"
6627 def GetAngleRadians(self, theShape1, theShape2):
6629 Get angle between the given shapes in radians.
6632 theShape1,theShape2 Lines or linear edges to find angle between.
6636 If both arguments are vectors, the angle is computed in accordance
6637 with their orientations, otherwise the minimum angle is computed.
6640 Value of the angle between the given shapes in radians.
6642 # Example: see GEOM_TestMeasures.py
6643 anAngle = self.MeasuOp.GetAngle(theShape1, theShape2)*math.pi/180.
6644 RaiseIfFailed("GetAngle", self.MeasuOp)
6647 ## Get angle between the given vectors in degrees.
6648 # @param theShape1,theShape2 Vectors to find angle between.
6649 # @param theFlag If True, the normal vector is defined by the two vectors cross,
6650 # if False, the opposite vector to the normal vector is used.
6651 # @return Value of the angle between the given vectors in degrees.
6653 # @ref tui_measurement_tools_page "Example"
6654 def GetAngleVectors(self, theShape1, theShape2, theFlag = True):
6656 Get angle between the given vectors in degrees.
6659 theShape1,theShape2 Vectors to find angle between.
6660 theFlag If True, the normal vector is defined by the two vectors cross,
6661 if False, the opposite vector to the normal vector is used.
6664 Value of the angle between the given vectors in degrees.
6666 anAngle = self.MeasuOp.GetAngleBtwVectors(theShape1, theShape2)
6668 anAngle = 360. - anAngle
6669 RaiseIfFailed("GetAngleVectors", self.MeasuOp)
6672 ## The same as GetAngleVectors, but the result is in radians.
6673 def GetAngleRadiansVectors(self, theShape1, theShape2, theFlag = True):
6675 Get angle between the given vectors in radians.
6678 theShape1,theShape2 Vectors to find angle between.
6679 theFlag If True, the normal vector is defined by the two vectors cross,
6680 if False, the opposite vector to the normal vector is used.
6683 Value of the angle between the given vectors in radians.
6685 anAngle = self.GetAngleVectors(theShape1, theShape2, theFlag)*math.pi/180.
6688 ## @name Curve Curvature Measurement
6689 # Methods for receiving radius of curvature of curves
6690 # in the given point
6693 ## Measure curvature of a curve at a point, set by parameter.
6694 # @param theCurve a curve.
6695 # @param theParam parameter.
6696 # @return radius of curvature of \a theCurve.
6698 # @ref swig_todo "Example"
6699 def CurveCurvatureByParam(self, theCurve, theParam):
6701 Measure curvature of a curve at a point, set by parameter.
6708 radius of curvature of theCurve.
6710 # Example: see GEOM_TestMeasures.py
6711 aCurv = self.MeasuOp.CurveCurvatureByParam(theCurve,theParam)
6712 RaiseIfFailed("CurveCurvatureByParam", self.MeasuOp)
6715 ## Measure curvature of a curve at a point.
6716 # @param theCurve a curve.
6717 # @param thePoint given point.
6718 # @return radius of curvature of \a theCurve.
6720 # @ref swig_todo "Example"
6721 def CurveCurvatureByPoint(self, theCurve, thePoint):
6723 Measure curvature of a curve at a point.
6727 thePoint given point.
6730 radius of curvature of theCurve.
6732 aCurv = self.MeasuOp.CurveCurvatureByPoint(theCurve,thePoint)
6733 RaiseIfFailed("CurveCurvatureByPoint", self.MeasuOp)
6737 ## @name Surface Curvature Measurement
6738 # Methods for receiving max and min radius of curvature of surfaces
6739 # in the given point
6742 ## Measure max radius of curvature of surface.
6743 # @param theSurf the given surface.
6744 # @param theUParam Value of U-parameter on the referenced surface.
6745 # @param theVParam Value of V-parameter on the referenced surface.
6746 # @return max radius of curvature of theSurf.
6748 ## @ref swig_todo "Example"
6749 def MaxSurfaceCurvatureByParam(self, theSurf, theUParam, theVParam):
6751 Measure max radius of curvature of surface.
6754 theSurf the given surface.
6755 theUParam Value of U-parameter on the referenced surface.
6756 theVParam Value of V-parameter on the referenced surface.
6759 max radius of curvature of theSurf.
6761 # Example: see GEOM_TestMeasures.py
6762 aSurf = self.MeasuOp.MaxSurfaceCurvatureByParam(theSurf,theUParam,theVParam)
6763 RaiseIfFailed("MaxSurfaceCurvatureByParam", self.MeasuOp)
6766 ## Measure max radius of curvature of surface in the given point
6767 # @param theSurf the given surface.
6768 # @param thePoint given point.
6769 # @return max radius of curvature of theSurf.
6771 ## @ref swig_todo "Example"
6772 def MaxSurfaceCurvatureByPoint(self, theSurf, thePoint):
6774 Measure max radius of curvature of surface in the given point.
6777 theSurf the given surface.
6778 thePoint given point.
6781 max radius of curvature of theSurf.
6783 aSurf = self.MeasuOp.MaxSurfaceCurvatureByPoint(theSurf,thePoint)
6784 RaiseIfFailed("MaxSurfaceCurvatureByPoint", self.MeasuOp)
6787 ## Measure min radius of curvature of surface.
6788 # @param theSurf the given surface.
6789 # @param theUParam Value of U-parameter on the referenced surface.
6790 # @param theVParam Value of V-parameter on the referenced surface.
6791 # @return min radius of curvature of theSurf.
6793 ## @ref swig_todo "Example"
6794 def MinSurfaceCurvatureByParam(self, theSurf, theUParam, theVParam):
6796 Measure min radius of curvature of surface.
6799 theSurf the given surface.
6800 theUParam Value of U-parameter on the referenced surface.
6801 theVParam Value of V-parameter on the referenced surface.
6804 Min radius of curvature of theSurf.
6806 aSurf = self.MeasuOp.MinSurfaceCurvatureByParam(theSurf,theUParam,theVParam)
6807 RaiseIfFailed("MinSurfaceCurvatureByParam", self.MeasuOp)
6810 ## Measure min radius of curvature of surface in the given point
6811 # @param theSurf the given surface.
6812 # @param thePoint given point.
6813 # @return min radius of curvature of theSurf.
6815 ## @ref swig_todo "Example"
6816 def MinSurfaceCurvatureByPoint(self, theSurf, thePoint):
6818 Measure min radius of curvature of surface in the given point.
6821 theSurf the given surface.
6822 thePoint given point.
6825 Min radius of curvature of theSurf.
6827 aSurf = self.MeasuOp.MinSurfaceCurvatureByPoint(theSurf,thePoint)
6828 RaiseIfFailed("MinSurfaceCurvatureByPoint", self.MeasuOp)
6832 ## Get min and max tolerances of sub-shapes of theShape
6833 # @param theShape Shape, to get tolerances of.
6834 # @return [FaceMin,FaceMax, EdgeMin,EdgeMax, VertMin,VertMax]\n
6835 # FaceMin,FaceMax: Min and max tolerances of the faces.\n
6836 # EdgeMin,EdgeMax: Min and max tolerances of the edges.\n
6837 # VertMin,VertMax: Min and max tolerances of the vertices.
6839 # @ref tui_measurement_tools_page "Example"
6840 def Tolerance(self,theShape):
6842 Get min and max tolerances of sub-shapes of theShape
6845 theShape Shape, to get tolerances of.
6848 [FaceMin,FaceMax, EdgeMin,EdgeMax, VertMin,VertMax]
6849 FaceMin,FaceMax: Min and max tolerances of the faces.
6850 EdgeMin,EdgeMax: Min and max tolerances of the edges.
6851 VertMin,VertMax: Min and max tolerances of the vertices.
6853 # Example: see GEOM_TestMeasures.py
6854 aTuple = self.MeasuOp.GetTolerance(theShape)
6855 RaiseIfFailed("GetTolerance", self.MeasuOp)
6858 ## Obtain description of the given shape (number of sub-shapes of each type)
6859 # @param theShape Shape to be described.
6860 # @return Description of the given shape.
6862 # @ref tui_measurement_tools_page "Example"
6863 def WhatIs(self,theShape):
6865 Obtain description of the given shape (number of sub-shapes of each type)
6868 theShape Shape to be described.
6871 Description of the given shape.
6873 # Example: see GEOM_TestMeasures.py
6874 aDescr = self.MeasuOp.WhatIs(theShape)
6875 RaiseIfFailed("WhatIs", self.MeasuOp)
6878 ## Obtain quantity of shapes of the given type in \a theShape.
6879 # If \a theShape is of type \a theType, it is also counted.
6880 # @param theShape Shape to be described.
6881 # @param theType the given ShapeType().
6882 # @return Quantity of shapes of type \a theType in \a theShape.
6884 # @ref tui_measurement_tools_page "Example"
6885 def NbShapes (self, theShape, theType):
6887 Obtain quantity of shapes of the given type in theShape.
6888 If theShape is of type theType, it is also counted.
6891 theShape Shape to be described.
6892 theType the given geompy.ShapeType
6895 Quantity of shapes of type theType in theShape.
6897 # Example: see GEOM_TestMeasures.py
6898 listSh = self.SubShapeAllIDs(theShape, theType)
6900 t = EnumToLong(theShape.GetShapeType())
6901 theType = EnumToLong(theType)
6907 ## Obtain quantity of shapes of each type in \a theShape.
6908 # The \a theShape is also counted.
6909 # @param theShape Shape to be described.
6910 # @return Dictionary of ShapeType() with bound quantities of shapes.
6912 # @ref tui_measurement_tools_page "Example"
6913 def ShapeInfo (self, theShape):
6915 Obtain quantity of shapes of each type in theShape.
6916 The theShape is also counted.
6919 theShape Shape to be described.
6922 Dictionary of geompy.ShapeType with bound quantities of shapes.
6924 # Example: see GEOM_TestMeasures.py
6926 for typeSh in ShapeType:
6927 if typeSh in ( "AUTO", "SHAPE" ): continue
6928 listSh = self.SubShapeAllIDs(theShape, ShapeType[typeSh])
6930 if EnumToLong(theShape.GetShapeType()) == ShapeType[typeSh]:
6937 ## Get a point, situated at the centre of mass of theShape.
6938 # @param theShape Shape to define centre of mass of.
6939 # @return New GEOM.GEOM_Object, containing the created point.
6941 # @ref tui_measurement_tools_page "Example"
6942 def MakeCDG(self,theShape):
6944 Get a point, situated at the centre of mass of theShape.
6947 theShape Shape to define centre of mass of.
6950 New GEOM.GEOM_Object, containing the created point.
6952 # Example: see GEOM_TestMeasures.py
6953 anObj = self.MeasuOp.GetCentreOfMass(theShape)
6954 RaiseIfFailed("GetCentreOfMass", self.MeasuOp)
6957 ## Get a vertex sub-shape by index depended with orientation.
6958 # @param theShape Shape to find sub-shape.
6959 # @param theIndex Index to find vertex by this index (starting from zero)
6960 # @return New GEOM.GEOM_Object, containing the created vertex.
6962 # @ref tui_measurement_tools_page "Example"
6963 def GetVertexByIndex(self,theShape, theIndex):
6965 Get a vertex sub-shape by index depended with orientation.
6968 theShape Shape to find sub-shape.
6969 theIndex Index to find vertex by this index (starting from zero)
6972 New GEOM.GEOM_Object, containing the created vertex.
6974 # Example: see GEOM_TestMeasures.py
6975 anObj = self.MeasuOp.GetVertexByIndex(theShape, theIndex)
6976 RaiseIfFailed("GetVertexByIndex", self.MeasuOp)
6979 ## Get the first vertex of wire/edge depended orientation.
6980 # @param theShape Shape to find first vertex.
6981 # @return New GEOM.GEOM_Object, containing the created vertex.
6983 # @ref tui_measurement_tools_page "Example"
6984 def GetFirstVertex(self,theShape):
6986 Get the first vertex of wire/edge depended orientation.
6989 theShape Shape to find first vertex.
6992 New GEOM.GEOM_Object, containing the created vertex.
6994 # Example: see GEOM_TestMeasures.py
6995 anObj = self.GetVertexByIndex(theShape, 0)
6996 RaiseIfFailed("GetFirstVertex", self.MeasuOp)
6999 ## Get the last vertex of wire/edge depended orientation.
7000 # @param theShape Shape to find last vertex.
7001 # @return New GEOM.GEOM_Object, containing the created vertex.
7003 # @ref tui_measurement_tools_page "Example"
7004 def GetLastVertex(self,theShape):
7006 Get the last vertex of wire/edge depended orientation.
7009 theShape Shape to find last vertex.
7012 New GEOM.GEOM_Object, containing the created vertex.
7014 # Example: see GEOM_TestMeasures.py
7015 nb_vert = self.ShapesOp.NumberOfSubShapes(theShape, ShapeType["VERTEX"])
7016 anObj = self.GetVertexByIndex(theShape, (nb_vert-1))
7017 RaiseIfFailed("GetLastVertex", self.MeasuOp)
7020 ## Get a normale to the given face. If the point is not given,
7021 # the normale is calculated at the center of mass.
7022 # @param theFace Face to define normale of.
7023 # @param theOptionalPoint Point to compute the normale at.
7024 # @return New GEOM.GEOM_Object, containing the created vector.
7026 # @ref swig_todo "Example"
7027 def GetNormal(self, theFace, theOptionalPoint = None):
7029 Get a normale to the given face. If the point is not given,
7030 the normale is calculated at the center of mass.
7033 theFace Face to define normale of.
7034 theOptionalPoint Point to compute the normale at.
7037 New GEOM.GEOM_Object, containing the created vector.
7039 # Example: see GEOM_TestMeasures.py
7040 anObj = self.MeasuOp.GetNormal(theFace, theOptionalPoint)
7041 RaiseIfFailed("GetNormal", self.MeasuOp)
7044 ## Check a topology of the given shape.
7045 # @param theShape Shape to check validity of.
7046 # @param theIsCheckGeom If FALSE, only the shape's topology will be checked, \n
7047 # if TRUE, the shape's geometry will be checked also.
7048 # @param theReturnStatus If FALSE and if theShape is invalid, a description \n
7049 # of problem is printed.
7050 # if TRUE and if theShape is invalid, the description
7051 # of problem is also returned.
7052 # @return TRUE, if the shape "seems to be valid".
7054 # @ref tui_measurement_tools_page "Example"
7055 def CheckShape(self,theShape, theIsCheckGeom = 0, theReturnStatus = 0):
7057 Check a topology of the given shape.
7060 theShape Shape to check validity of.
7061 theIsCheckGeom If FALSE, only the shape's topology will be checked,
7062 if TRUE, the shape's geometry will be checked also.
7063 theReturnStatus If FALSE and if theShape is invalid, a description
7064 of problem is printed.
7065 if TRUE and if theShape is invalid, the description
7066 of problem is returned.
7069 TRUE, if the shape "seems to be valid".
7070 If theShape is invalid, prints a description of problem.
7071 This description can also be returned.
7073 # Example: see GEOM_TestMeasures.py
7075 (IsValid, Status) = self.MeasuOp.CheckShapeWithGeometry(theShape)
7076 RaiseIfFailed("CheckShapeWithGeometry", self.MeasuOp)
7078 (IsValid, Status) = self.MeasuOp.CheckShape(theShape)
7079 RaiseIfFailed("CheckShape", self.MeasuOp)
7081 if theReturnStatus == 0:
7083 if theReturnStatus == 1:
7084 return (IsValid, Status)
7087 ## Detect self-intersections in the given shape.
7088 # @param theShape Shape to check.
7089 # @return TRUE, if the shape contains no self-intersections.
7091 # @ref tui_measurement_tools_page "Example"
7092 def CheckSelfIntersections(self, theShape):
7094 Detect self-intersections in the given shape.
7097 theShape Shape to check.
7100 TRUE, if the shape contains no self-intersections.
7102 # Example: see GEOM_TestMeasures.py
7103 (IsValid, Pairs) = self.MeasuOp.CheckSelfIntersections(theShape)
7104 RaiseIfFailed("CheckSelfIntersections", self.MeasuOp)
7107 ## Get position (LCS) of theShape.
7109 # Origin of the LCS is situated at the shape's center of mass.
7110 # Axes of the LCS are obtained from shape's location or,
7111 # if the shape is a planar face, from position of its plane.
7113 # @param theShape Shape to calculate position of.
7114 # @return [Ox,Oy,Oz, Zx,Zy,Zz, Xx,Xy,Xz].
7115 # Ox,Oy,Oz: Coordinates of shape's LCS origin.
7116 # Zx,Zy,Zz: Coordinates of shape's LCS normal(main) direction.
7117 # Xx,Xy,Xz: Coordinates of shape's LCS X direction.
7119 # @ref swig_todo "Example"
7120 def GetPosition(self,theShape):
7122 Get position (LCS) of theShape.
7123 Origin of the LCS is situated at the shape's center of mass.
7124 Axes of the LCS are obtained from shape's location or,
7125 if the shape is a planar face, from position of its plane.
7128 theShape Shape to calculate position of.
7131 [Ox,Oy,Oz, Zx,Zy,Zz, Xx,Xy,Xz].
7132 Ox,Oy,Oz: Coordinates of shape's LCS origin.
7133 Zx,Zy,Zz: Coordinates of shape's LCS normal(main) direction.
7134 Xx,Xy,Xz: Coordinates of shape's LCS X direction.
7136 # Example: see GEOM_TestMeasures.py
7137 aTuple = self.MeasuOp.GetPosition(theShape)
7138 RaiseIfFailed("GetPosition", self.MeasuOp)
7141 ## Get kind of theShape.
7143 # @param theShape Shape to get a kind of.
7144 # @return Returns a kind of shape in terms of <VAR>GEOM.GEOM_IKindOfShape.shape_kind</VAR> enumeration
7145 # and a list of parameters, describing the shape.
7146 # @note Concrete meaning of each value, returned via \a theIntegers
7147 # or \a theDoubles list depends on the kind() of the shape.
7149 # @ref swig_todo "Example"
7150 def KindOfShape(self,theShape):
7152 Get kind of theShape.
7155 theShape Shape to get a kind of.
7158 a kind of shape in terms of GEOM_IKindOfShape.shape_kind enumeration
7159 and a list of parameters, describing the shape.
7161 Concrete meaning of each value, returned via theIntegers
7162 or theDoubles list depends on the geompy.kind of the shape
7164 # Example: see GEOM_TestMeasures.py
7165 aRoughTuple = self.MeasuOp.KindOfShape(theShape)
7166 RaiseIfFailed("KindOfShape", self.MeasuOp)
7168 aKind = aRoughTuple[0]
7169 anInts = aRoughTuple[1]
7170 aDbls = aRoughTuple[2]
7172 # Now there is no exception from this rule:
7173 aKindTuple = [aKind] + aDbls + anInts
7175 # If they are we will regroup parameters for such kind of shape.
7177 #if aKind == kind.SOME_KIND:
7178 # # SOME_KIND int int double int double double
7179 # aKindTuple = [aKind, anInts[0], anInts[1], aDbls[0], anInts[2], aDbls[1], aDbls[2]]
7186 ## @addtogroup l2_import_export
7189 ## Import a shape from the BREP or IGES or STEP file
7190 # (depends on given format) with given name.
7191 # @param theFileName The file, containing the shape.
7192 # @param theFormatName Specify format for the file reading.
7193 # Available formats can be obtained with InsertOp.ImportTranslators() method.
7194 # If format 'IGES_SCALE' is used instead 'IGES' length unit will be
7195 # set to 'meter' and result model will be scaled.
7196 # @return New GEOM.GEOM_Object, containing the imported shape.
7198 # @ref swig_Import_Export "Example"
7199 def ImportFile(self,theFileName, theFormatName):
7201 Import a shape from the BREP or IGES or STEP file
7202 (depends on given format) with given name.
7205 theFileName The file, containing the shape.
7206 theFormatName Specify format for the file reading.
7207 Available formats can be obtained with geompy.InsertOp.ImportTranslators() method.
7208 If format 'IGES_SCALE' is used instead 'IGES' length unit will be
7209 set to 'meter' and result model will be scaled.
7212 New GEOM.GEOM_Object, containing the imported shape.
7214 # Example: see GEOM_TestOthers.py
7215 anObj = self.InsertOp.ImportFile(theFileName, theFormatName)
7216 RaiseIfFailed("Import", self.InsertOp)
7219 ## Deprecated analog of ImportFile()
7220 def Import(self,theFileName, theFormatName):
7222 Deprecated analog of geompy.ImportFile
7224 print "WARNING: Function Import is deprecated, use ImportFile instead"
7225 anObj = self.InsertOp.ImportFile(theFileName, theFormatName)
7226 RaiseIfFailed("Import", self.InsertOp)
7229 ## Shortcut to ImportFile() for BREP format
7231 # @ref swig_Import_Export "Example"
7232 def ImportBREP(self,theFileName):
7234 geompy.ImportFile(...) function for BREP format
7236 # Example: see GEOM_TestOthers.py
7237 return self.ImportFile(theFileName, "BREP")
7239 ## Shortcut to ImportFile() for IGES format
7241 # @ref swig_Import_Export "Example"
7242 def ImportIGES(self,theFileName):
7244 geompy.ImportFile(...) function for IGES format
7246 # Example: see GEOM_TestOthers.py
7247 return self.ImportFile(theFileName, "IGES")
7249 ## Return length unit from given IGES file
7251 # @ref swig_Import_Export "Example"
7252 def GetIGESUnit(self,theFileName):
7254 Return length unit from given IGES file
7256 # Example: see GEOM_TestOthers.py
7257 anObj = self.InsertOp.ImportFile(theFileName, "IGES_UNIT")
7258 #RaiseIfFailed("Import", self.InsertOp)
7259 # recieve name using returned vertex
7261 if anObj.GetShapeType() == GEOM.VERTEX:
7264 vertices = self.SubShapeAll(anObj,ShapeType["VERTEX"])
7266 p = self.PointCoordinates(vertices[0])
7267 if abs(p[0]-0.01) < 1.e-6:
7269 elif abs(p[0]-0.001) < 1.e-6:
7273 ## Shortcut to ImportFile() for STEP format
7275 # @ref swig_Import_Export "Example"
7276 def ImportSTEP(self,theFileName):
7278 geompy.ImportFile(...) function for STEP format
7280 # Example: see GEOM_TestOthers.py
7281 return self.ImportFile(theFileName, "STEP")
7283 ## Export the given shape into a file with given name.
7284 # @param theObject Shape to be stored in the file.
7285 # @param theFileName Name of the file to store the given shape in.
7286 # @param theFormatName Specify format for the shape storage.
7287 # Available formats can be obtained with InsertOp.ImportTranslators() method.
7289 # @ref swig_Import_Export "Example"
7290 def Export(self,theObject, theFileName, theFormatName):
7292 Export the given shape into a file with given name.
7295 theObject Shape to be stored in the file.
7296 theFileName Name of the file to store the given shape in.
7297 theFormatName Specify format for the shape storage.
7298 Available formats can be obtained with geompy.InsertOp.ImportTranslators() method.
7300 # Example: see GEOM_TestOthers.py
7301 self.InsertOp.Export(theObject, theFileName, theFormatName)
7302 if self.InsertOp.IsDone() == 0:
7303 raise RuntimeError, "Export : " + self.InsertOp.GetErrorCode()
7307 ## Shortcut to Export() for BREP format
7309 # @ref swig_Import_Export "Example"
7310 def ExportBREP(self,theObject, theFileName):
7312 geompy.Export(...) function for BREP format
7314 # Example: see GEOM_TestOthers.py
7315 return self.Export(theObject, theFileName, "BREP")
7317 ## Shortcut to Export() for IGES format
7319 # @ref swig_Import_Export "Example"
7320 def ExportIGES(self,theObject, theFileName):
7322 geompy.Export(...) function for IGES format
7324 # Example: see GEOM_TestOthers.py
7325 return self.Export(theObject, theFileName, "IGES")
7327 ## Shortcut to Export() for STEP format
7329 # @ref swig_Import_Export "Example"
7330 def ExportSTEP(self,theObject, theFileName):
7332 geompy.Export(...) function for STEP format
7334 # Example: see GEOM_TestOthers.py
7335 return self.Export(theObject, theFileName, "STEP")
7337 # end of l2_import_export
7340 ## @addtogroup l3_blocks
7343 ## Create a quadrangle face from four edges. Order of Edges is not
7344 # important. It is not necessary that edges share the same vertex.
7345 # @param E1,E2,E3,E4 Edges for the face bound.
7346 # @return New GEOM.GEOM_Object, containing the created face.
7348 # @ref tui_building_by_blocks_page "Example"
7349 def MakeQuad(self,E1, E2, E3, E4):
7351 Create a quadrangle face from four edges. Order of Edges is not
7352 important. It is not necessary that edges share the same vertex.
7355 E1,E2,E3,E4 Edges for the face bound.
7358 New GEOM.GEOM_Object, containing the created face.
7361 qface1 = geompy.MakeQuad(edge1, edge2, edge3, edge4)
7363 # Example: see GEOM_Spanner.py
7364 anObj = self.BlocksOp.MakeQuad(E1, E2, E3, E4)
7365 RaiseIfFailed("MakeQuad", self.BlocksOp)
7368 ## Create a quadrangle face on two edges.
7369 # The missing edges will be built by creating the shortest ones.
7370 # @param E1,E2 Two opposite edges for the face.
7371 # @return New GEOM.GEOM_Object, containing the created face.
7373 # @ref tui_building_by_blocks_page "Example"
7374 def MakeQuad2Edges(self,E1, E2):
7376 Create a quadrangle face on two edges.
7377 The missing edges will be built by creating the shortest ones.
7380 E1,E2 Two opposite edges for the face.
7383 New GEOM.GEOM_Object, containing the created face.
7387 p1 = geompy.MakeVertex( 0., 0., 0.)
7388 p2 = geompy.MakeVertex(150., 30., 0.)
7389 p3 = geompy.MakeVertex( 0., 120., 50.)
7390 p4 = geompy.MakeVertex( 0., 40., 70.)
7392 edge1 = geompy.MakeEdge(p1, p2)
7393 edge2 = geompy.MakeEdge(p3, p4)
7394 # create a quadrangle face from two edges
7395 qface2 = geompy.MakeQuad2Edges(edge1, edge2)
7397 # Example: see GEOM_Spanner.py
7398 anObj = self.BlocksOp.MakeQuad2Edges(E1, E2)
7399 RaiseIfFailed("MakeQuad2Edges", self.BlocksOp)
7402 ## Create a quadrangle face with specified corners.
7403 # The missing edges will be built by creating the shortest ones.
7404 # @param V1,V2,V3,V4 Corner vertices for the face.
7405 # @return New GEOM.GEOM_Object, containing the created face.
7407 # @ref tui_building_by_blocks_page "Example 1"
7408 # \n @ref swig_MakeQuad4Vertices "Example 2"
7409 def MakeQuad4Vertices(self,V1, V2, V3, V4):
7411 Create a quadrangle face with specified corners.
7412 The missing edges will be built by creating the shortest ones.
7415 V1,V2,V3,V4 Corner vertices for the face.
7418 New GEOM.GEOM_Object, containing the created face.
7422 p1 = geompy.MakeVertex( 0., 0., 0.)
7423 p2 = geompy.MakeVertex(150., 30., 0.)
7424 p3 = geompy.MakeVertex( 0., 120., 50.)
7425 p4 = geompy.MakeVertex( 0., 40., 70.)
7426 # create a quadrangle from four points in its corners
7427 qface3 = geompy.MakeQuad4Vertices(p1, p2, p3, p4)
7429 # Example: see GEOM_Spanner.py
7430 anObj = self.BlocksOp.MakeQuad4Vertices(V1, V2, V3, V4)
7431 RaiseIfFailed("MakeQuad4Vertices", self.BlocksOp)
7434 ## Create a hexahedral solid, bounded by the six given faces. Order of
7435 # faces is not important. It is not necessary that Faces share the same edge.
7436 # @param F1,F2,F3,F4,F5,F6 Faces for the hexahedral solid.
7437 # @return New GEOM.GEOM_Object, containing the created solid.
7439 # @ref tui_building_by_blocks_page "Example 1"
7440 # \n @ref swig_MakeHexa "Example 2"
7441 def MakeHexa(self,F1, F2, F3, F4, F5, F6):
7443 Create a hexahedral solid, bounded by the six given faces. Order of
7444 faces is not important. It is not necessary that Faces share the same edge.
7447 F1,F2,F3,F4,F5,F6 Faces for the hexahedral solid.
7450 New GEOM.GEOM_Object, containing the created solid.
7453 solid = geompy.MakeHexa(qface1, qface2, qface3, qface4, qface5, qface6)
7455 # Example: see GEOM_Spanner.py
7456 anObj = self.BlocksOp.MakeHexa(F1, F2, F3, F4, F5, F6)
7457 RaiseIfFailed("MakeHexa", self.BlocksOp)
7460 ## Create a hexahedral solid between two given faces.
7461 # The missing faces will be built by creating the smallest ones.
7462 # @param F1,F2 Two opposite faces for the hexahedral solid.
7463 # @return New GEOM.GEOM_Object, containing the created solid.
7465 # @ref tui_building_by_blocks_page "Example 1"
7466 # \n @ref swig_MakeHexa2Faces "Example 2"
7467 def MakeHexa2Faces(self,F1, F2):
7469 Create a hexahedral solid between two given faces.
7470 The missing faces will be built by creating the smallest ones.
7473 F1,F2 Two opposite faces for the hexahedral solid.
7476 New GEOM.GEOM_Object, containing the created solid.
7479 solid1 = geompy.MakeHexa2Faces(qface1, qface2)
7481 # Example: see GEOM_Spanner.py
7482 anObj = self.BlocksOp.MakeHexa2Faces(F1, F2)
7483 RaiseIfFailed("MakeHexa2Faces", self.BlocksOp)
7489 ## @addtogroup l3_blocks_op
7492 ## Get a vertex, found in the given shape by its coordinates.
7493 # @param theShape Block or a compound of blocks.
7494 # @param theX,theY,theZ Coordinates of the sought vertex.
7495 # @param theEpsilon Maximum allowed distance between the resulting
7496 # vertex and point with the given coordinates.
7497 # @return New GEOM.GEOM_Object, containing the found vertex.
7499 # @ref swig_GetPoint "Example"
7500 def GetPoint(self, theShape, theX, theY, theZ, theEpsilon):
7502 Get a vertex, found in the given shape by its coordinates.
7505 theShape Block or a compound of blocks.
7506 theX,theY,theZ Coordinates of the sought vertex.
7507 theEpsilon Maximum allowed distance between the resulting
7508 vertex and point with the given coordinates.
7511 New GEOM.GEOM_Object, containing the found vertex.
7514 pnt = geompy.GetPoint(shape, -50, 50, 50, 0.01)
7516 # Example: see GEOM_TestOthers.py
7517 anObj = self.BlocksOp.GetPoint(theShape, theX, theY, theZ, theEpsilon)
7518 RaiseIfFailed("GetPoint", self.BlocksOp)
7521 ## Find a vertex of the given shape, which has minimal distance to the given point.
7522 # @param theShape Any shape.
7523 # @param thePoint Point, close to the desired vertex.
7524 # @return New GEOM.GEOM_Object, containing the found vertex.
7526 # @ref swig_GetVertexNearPoint "Example"
7527 def GetVertexNearPoint(self, theShape, thePoint):
7529 Find a vertex of the given shape, which has minimal distance to the given point.
7533 thePoint Point, close to the desired vertex.
7536 New GEOM.GEOM_Object, containing the found vertex.
7539 pmidle = geompy.MakeVertex(50, 0, 50)
7540 edge1 = geompy.GetEdgeNearPoint(blocksComp, pmidle)
7542 # Example: see GEOM_TestOthers.py
7543 anObj = self.BlocksOp.GetVertexNearPoint(theShape, thePoint)
7544 RaiseIfFailed("GetVertexNearPoint", self.BlocksOp)
7547 ## Get an edge, found in the given shape by two given vertices.
7548 # @param theShape Block or a compound of blocks.
7549 # @param thePoint1,thePoint2 Points, close to the ends of the desired edge.
7550 # @return New GEOM.GEOM_Object, containing the found edge.
7552 # @ref swig_GetEdge "Example"
7553 def GetEdge(self, theShape, thePoint1, thePoint2):
7555 Get an edge, found in the given shape by two given vertices.
7558 theShape Block or a compound of blocks.
7559 thePoint1,thePoint2 Points, close to the ends of the desired edge.
7562 New GEOM.GEOM_Object, containing the found edge.
7564 # Example: see GEOM_Spanner.py
7565 anObj = self.BlocksOp.GetEdge(theShape, thePoint1, thePoint2)
7566 RaiseIfFailed("GetEdge", self.BlocksOp)
7569 ## Find an edge of the given shape, which has minimal distance to the given point.
7570 # @param theShape Block or a compound of blocks.
7571 # @param thePoint Point, close to the desired edge.
7572 # @return New GEOM.GEOM_Object, containing the found edge.
7574 # @ref swig_GetEdgeNearPoint "Example"
7575 def GetEdgeNearPoint(self, theShape, thePoint):
7577 Find an edge of the given shape, which has minimal distance to the given point.
7580 theShape Block or a compound of blocks.
7581 thePoint Point, close to the desired edge.
7584 New GEOM.GEOM_Object, containing the found edge.
7586 # Example: see GEOM_TestOthers.py
7587 anObj = self.BlocksOp.GetEdgeNearPoint(theShape, thePoint)
7588 RaiseIfFailed("GetEdgeNearPoint", self.BlocksOp)
7591 ## Returns a face, found in the given shape by four given corner vertices.
7592 # @param theShape Block or a compound of blocks.
7593 # @param thePoint1,thePoint2,thePoint3,thePoint4 Points, close to the corners of the desired face.
7594 # @return New GEOM.GEOM_Object, containing the found face.
7596 # @ref swig_todo "Example"
7597 def GetFaceByPoints(self,theShape, thePoint1, thePoint2, thePoint3, thePoint4):
7599 Returns a face, found in the given shape by four given corner vertices.
7602 theShape Block or a compound of blocks.
7603 thePoint1,thePoint2,thePoint3,thePoint4 Points, close to the corners of the desired face.
7606 New GEOM.GEOM_Object, containing the found face.
7608 # Example: see GEOM_Spanner.py
7609 anObj = self.BlocksOp.GetFaceByPoints(theShape, thePoint1, thePoint2, thePoint3, thePoint4)
7610 RaiseIfFailed("GetFaceByPoints", self.BlocksOp)
7613 ## Get a face of block, found in the given shape by two given edges.
7614 # @param theShape Block or a compound of blocks.
7615 # @param theEdge1,theEdge2 Edges, close to the edges of the desired face.
7616 # @return New GEOM.GEOM_Object, containing the found face.
7618 # @ref swig_todo "Example"
7619 def GetFaceByEdges(self,theShape, theEdge1, theEdge2):
7621 Get a face of block, found in the given shape by two given edges.
7624 theShape Block or a compound of blocks.
7625 theEdge1,theEdge2 Edges, close to the edges of the desired face.
7628 New GEOM.GEOM_Object, containing the found face.
7630 # Example: see GEOM_Spanner.py
7631 anObj = self.BlocksOp.GetFaceByEdges(theShape, theEdge1, theEdge2)
7632 RaiseIfFailed("GetFaceByEdges", self.BlocksOp)
7635 ## Find a face, opposite to the given one in the given block.
7636 # @param theBlock Must be a hexahedral solid.
7637 # @param theFace Face of \a theBlock, opposite to the desired face.
7638 # @return New GEOM.GEOM_Object, containing the found face.
7640 # @ref swig_GetOppositeFace "Example"
7641 def GetOppositeFace(self,theBlock, theFace):
7643 Find a face, opposite to the given one in the given block.
7646 theBlock Must be a hexahedral solid.
7647 theFace Face of theBlock, opposite to the desired face.
7650 New GEOM.GEOM_Object, containing the found face.
7652 # Example: see GEOM_Spanner.py
7653 anObj = self.BlocksOp.GetOppositeFace(theBlock, theFace)
7654 RaiseIfFailed("GetOppositeFace", self.BlocksOp)
7657 ## Find a face of the given shape, which has minimal distance to the given point.
7658 # @param theShape Block or a compound of blocks.
7659 # @param thePoint Point, close to the desired face.
7660 # @return New GEOM.GEOM_Object, containing the found face.
7662 # @ref swig_GetFaceNearPoint "Example"
7663 def GetFaceNearPoint(self, theShape, thePoint):
7665 Find a face of the given shape, which has minimal distance to the given point.
7668 theShape Block or a compound of blocks.
7669 thePoint Point, close to the desired face.
7672 New GEOM.GEOM_Object, containing the found face.
7674 # Example: see GEOM_Spanner.py
7675 anObj = self.BlocksOp.GetFaceNearPoint(theShape, thePoint)
7676 RaiseIfFailed("GetFaceNearPoint", self.BlocksOp)
7679 ## Find a face of block, whose outside normale has minimal angle with the given vector.
7680 # @param theBlock Block or a compound of blocks.
7681 # @param theVector Vector, close to the normale of the desired face.
7682 # @return New GEOM.GEOM_Object, containing the found face.
7684 # @ref swig_todo "Example"
7685 def GetFaceByNormale(self, theBlock, theVector):
7687 Find a face of block, whose outside normale has minimal angle with the given vector.
7690 theBlock Block or a compound of blocks.
7691 theVector Vector, close to the normale of the desired face.
7694 New GEOM.GEOM_Object, containing the found face.
7696 # Example: see GEOM_Spanner.py
7697 anObj = self.BlocksOp.GetFaceByNormale(theBlock, theVector)
7698 RaiseIfFailed("GetFaceByNormale", self.BlocksOp)
7701 ## Find all sub-shapes of type \a theShapeType of the given shape,
7702 # which have minimal distance to the given point.
7703 # @param theShape Any shape.
7704 # @param thePoint Point, close to the desired shape.
7705 # @param theShapeType Defines what kind of sub-shapes is searched GEOM::shape_type
7706 # @param theTolerance The tolerance for distances comparison. All shapes
7707 # with distances to the given point in interval
7708 # [minimal_distance, minimal_distance + theTolerance] will be gathered.
7709 # @return New GEOM_Object, containing a group of all found shapes.
7711 # @ref swig_GetShapesNearPoint "Example"
7712 def GetShapesNearPoint(self, theShape, thePoint, theShapeType, theTolerance = 1e-07):
7714 Find all sub-shapes of type theShapeType of the given shape,
7715 which have minimal distance to the given point.
7719 thePoint Point, close to the desired shape.
7720 theShapeType Defines what kind of sub-shapes is searched (see GEOM::shape_type)
7721 theTolerance The tolerance for distances comparison. All shapes
7722 with distances to the given point in interval
7723 [minimal_distance, minimal_distance + theTolerance] will be gathered.
7726 New GEOM_Object, containing a group of all found shapes.
7728 # Example: see GEOM_TestOthers.py
7729 anObj = self.BlocksOp.GetShapesNearPoint(theShape, thePoint, theShapeType, theTolerance)
7730 RaiseIfFailed("GetShapesNearPoint", self.BlocksOp)
7733 # end of l3_blocks_op
7736 ## @addtogroup l4_blocks_measure
7739 ## Check, if the compound of blocks is given.
7740 # To be considered as a compound of blocks, the
7741 # given shape must satisfy the following conditions:
7742 # - Each element of the compound should be a Block (6 faces and 12 edges).
7743 # - A connection between two Blocks should be an entire quadrangle face or an entire edge.
7744 # - The compound should be connexe.
7745 # - The glue between two quadrangle faces should be applied.
7746 # @param theCompound The compound to check.
7747 # @return TRUE, if the given shape is a compound of blocks.
7748 # If theCompound is not valid, prints all discovered errors.
7750 # @ref tui_measurement_tools_page "Example 1"
7751 # \n @ref swig_CheckCompoundOfBlocks "Example 2"
7752 def CheckCompoundOfBlocks(self,theCompound):
7754 Check, if the compound of blocks is given.
7755 To be considered as a compound of blocks, the
7756 given shape must satisfy the following conditions:
7757 - Each element of the compound should be a Block (6 faces and 12 edges).
7758 - A connection between two Blocks should be an entire quadrangle face or an entire edge.
7759 - The compound should be connexe.
7760 - The glue between two quadrangle faces should be applied.
7763 theCompound The compound to check.
7766 TRUE, if the given shape is a compound of blocks.
7767 If theCompound is not valid, prints all discovered errors.
7769 # Example: see GEOM_Spanner.py
7770 (IsValid, BCErrors) = self.BlocksOp.CheckCompoundOfBlocks(theCompound)
7771 RaiseIfFailed("CheckCompoundOfBlocks", self.BlocksOp)
7773 Descr = self.BlocksOp.PrintBCErrors(theCompound, BCErrors)
7777 ## Retrieve all non blocks solids and faces from \a theShape.
7778 # @param theShape The shape to explore.
7779 # @return A tuple of two GEOM_Objects. The first object is a group of all
7780 # non block solids (= not 6 faces, or with 6 faces, but with the
7781 # presence of non-quadrangular faces). The second object is a
7782 # group of all non quadrangular faces.
7784 # @ref tui_measurement_tools_page "Example 1"
7785 # \n @ref swig_GetNonBlocks "Example 2"
7786 def GetNonBlocks (self, theShape):
7788 Retrieve all non blocks solids and faces from theShape.
7791 theShape The shape to explore.
7794 A tuple of two GEOM_Objects. The first object is a group of all
7795 non block solids (= not 6 faces, or with 6 faces, but with the
7796 presence of non-quadrangular faces). The second object is a
7797 group of all non quadrangular faces.
7800 (res_sols, res_faces) = geompy.GetNonBlocks(myShape1)
7802 # Example: see GEOM_Spanner.py
7803 aTuple = self.BlocksOp.GetNonBlocks(theShape)
7804 RaiseIfFailed("GetNonBlocks", self.BlocksOp)
7807 ## Remove all seam and degenerated edges from \a theShape.
7808 # Unite faces and edges, sharing one surface. It means that
7809 # this faces must have references to one C++ surface object (handle).
7810 # @param theShape The compound or single solid to remove irregular edges from.
7811 # @param doUnionFaces If True, then unite faces. If False (the default value),
7812 # do not unite faces.
7813 # @return Improved shape.
7815 # @ref swig_RemoveExtraEdges "Example"
7816 def RemoveExtraEdges(self, theShape, doUnionFaces=False):
7818 Remove all seam and degenerated edges from theShape.
7819 Unite faces and edges, sharing one surface. It means that
7820 this faces must have references to one C++ surface object (handle).
7823 theShape The compound or single solid to remove irregular edges from.
7824 doUnionFaces If True, then unite faces. If False (the default value),
7830 # Example: see GEOM_TestOthers.py
7831 nbFacesOptimum = -1 # -1 means do not unite faces
7832 if doUnionFaces is True: nbFacesOptimum = 0 # 0 means unite faces
7833 anObj = self.BlocksOp.RemoveExtraEdges(theShape, nbFacesOptimum)
7834 RaiseIfFailed("RemoveExtraEdges", self.BlocksOp)
7837 ## Check, if the given shape is a blocks compound.
7838 # Fix all detected errors.
7839 # \note Single block can be also fixed by this method.
7840 # @param theShape The compound to check and improve.
7841 # @return Improved compound.
7843 # @ref swig_CheckAndImprove "Example"
7844 def CheckAndImprove(self,theShape):
7846 Check, if the given shape is a blocks compound.
7847 Fix all detected errors.
7850 Single block can be also fixed by this method.
7853 theShape The compound to check and improve.
7858 # Example: see GEOM_TestOthers.py
7859 anObj = self.BlocksOp.CheckAndImprove(theShape)
7860 RaiseIfFailed("CheckAndImprove", self.BlocksOp)
7863 # end of l4_blocks_measure
7866 ## @addtogroup l3_blocks_op
7869 ## Get all the blocks, contained in the given compound.
7870 # @param theCompound The compound to explode.
7871 # @param theMinNbFaces If solid has lower number of faces, it is not a block.
7872 # @param theMaxNbFaces If solid has higher number of faces, it is not a block.
7873 # \note If theMaxNbFaces = 0, the maximum number of faces is not restricted.
7874 # @return List of GEOM.GEOM_Object, containing the retrieved blocks.
7876 # @ref tui_explode_on_blocks "Example 1"
7877 # \n @ref swig_MakeBlockExplode "Example 2"
7878 def MakeBlockExplode(self,theCompound, theMinNbFaces, theMaxNbFaces):
7880 Get all the blocks, contained in the given compound.
7883 theCompound The compound to explode.
7884 theMinNbFaces If solid has lower number of faces, it is not a block.
7885 theMaxNbFaces If solid has higher number of faces, it is not a block.
7888 If theMaxNbFaces = 0, the maximum number of faces is not restricted.
7891 List of GEOM.GEOM_Object, containing the retrieved blocks.
7893 # Example: see GEOM_TestOthers.py
7894 theMinNbFaces,theMaxNbFaces,Parameters = ParseParameters(theMinNbFaces,theMaxNbFaces)
7895 aList = self.BlocksOp.ExplodeCompoundOfBlocks(theCompound, theMinNbFaces, theMaxNbFaces)
7896 RaiseIfFailed("ExplodeCompoundOfBlocks", self.BlocksOp)
7898 anObj.SetParameters(Parameters)
7902 ## Find block, containing the given point inside its volume or on boundary.
7903 # @param theCompound Compound, to find block in.
7904 # @param thePoint Point, close to the desired block. If the point lays on
7905 # boundary between some blocks, we return block with nearest center.
7906 # @return New GEOM.GEOM_Object, containing the found block.
7908 # @ref swig_todo "Example"
7909 def GetBlockNearPoint(self,theCompound, thePoint):
7911 Find block, containing the given point inside its volume or on boundary.
7914 theCompound Compound, to find block in.
7915 thePoint Point, close to the desired block. If the point lays on
7916 boundary between some blocks, we return block with nearest center.
7919 New GEOM.GEOM_Object, containing the found block.
7921 # Example: see GEOM_Spanner.py
7922 anObj = self.BlocksOp.GetBlockNearPoint(theCompound, thePoint)
7923 RaiseIfFailed("GetBlockNearPoint", self.BlocksOp)
7926 ## Find block, containing all the elements, passed as the parts, or maximum quantity of them.
7927 # @param theCompound Compound, to find block in.
7928 # @param theParts List of faces and/or edges and/or vertices to be parts of the found block.
7929 # @return New GEOM.GEOM_Object, containing the found block.
7931 # @ref swig_GetBlockByParts "Example"
7932 def GetBlockByParts(self,theCompound, theParts):
7934 Find block, containing all the elements, passed as the parts, or maximum quantity of them.
7937 theCompound Compound, to find block in.
7938 theParts List of faces and/or edges and/or vertices to be parts of the found block.
7941 New GEOM_Object, containing the found block.
7943 # Example: see GEOM_TestOthers.py
7944 anObj = self.BlocksOp.GetBlockByParts(theCompound, theParts)
7945 RaiseIfFailed("GetBlockByParts", self.BlocksOp)
7948 ## Return all blocks, containing all the elements, passed as the parts.
7949 # @param theCompound Compound, to find blocks in.
7950 # @param theParts List of faces and/or edges and/or vertices to be parts of the found blocks.
7951 # @return List of GEOM.GEOM_Object, containing the found blocks.
7953 # @ref swig_todo "Example"
7954 def GetBlocksByParts(self,theCompound, theParts):
7956 Return all blocks, containing all the elements, passed as the parts.
7959 theCompound Compound, to find blocks in.
7960 theParts List of faces and/or edges and/or vertices to be parts of the found blocks.
7963 List of GEOM.GEOM_Object, containing the found blocks.
7965 # Example: see GEOM_Spanner.py
7966 aList = self.BlocksOp.GetBlocksByParts(theCompound, theParts)
7967 RaiseIfFailed("GetBlocksByParts", self.BlocksOp)
7970 ## Multi-transformate block and glue the result.
7971 # Transformation is defined so, as to superpose direction faces.
7972 # @param Block Hexahedral solid to be multi-transformed.
7973 # @param DirFace1 ID of First direction face.
7974 # @param DirFace2 ID of Second direction face.
7975 # @param NbTimes Quantity of transformations to be done.
7976 # \note Unique ID of sub-shape can be obtained, using method GetSubShapeID().
7977 # @return New GEOM.GEOM_Object, containing the result shape.
7979 # @ref tui_multi_transformation "Example"
7980 def MakeMultiTransformation1D(self,Block, DirFace1, DirFace2, NbTimes):
7982 Multi-transformate block and glue the result.
7983 Transformation is defined so, as to superpose direction faces.
7986 Block Hexahedral solid to be multi-transformed.
7987 DirFace1 ID of First direction face.
7988 DirFace2 ID of Second direction face.
7989 NbTimes Quantity of transformations to be done.
7992 Unique ID of sub-shape can be obtained, using method GetSubShapeID().
7995 New GEOM.GEOM_Object, containing the result shape.
7997 # Example: see GEOM_Spanner.py
7998 DirFace1,DirFace2,NbTimes,Parameters = ParseParameters(DirFace1,DirFace2,NbTimes)
7999 anObj = self.BlocksOp.MakeMultiTransformation1D(Block, DirFace1, DirFace2, NbTimes)
8000 RaiseIfFailed("MakeMultiTransformation1D", self.BlocksOp)
8001 anObj.SetParameters(Parameters)
8004 ## Multi-transformate block and glue the result.
8005 # @param Block Hexahedral solid to be multi-transformed.
8006 # @param DirFace1U,DirFace2U IDs of Direction faces for the first transformation.
8007 # @param DirFace1V,DirFace2V IDs of Direction faces for the second transformation.
8008 # @param NbTimesU,NbTimesV Quantity of transformations to be done.
8009 # @return New GEOM.GEOM_Object, containing the result shape.
8011 # @ref tui_multi_transformation "Example"
8012 def MakeMultiTransformation2D(self,Block, DirFace1U, DirFace2U, NbTimesU,
8013 DirFace1V, DirFace2V, NbTimesV):
8015 Multi-transformate block and glue the result.
8018 Block Hexahedral solid to be multi-transformed.
8019 DirFace1U,DirFace2U IDs of Direction faces for the first transformation.
8020 DirFace1V,DirFace2V IDs of Direction faces for the second transformation.
8021 NbTimesU,NbTimesV Quantity of transformations to be done.
8024 New GEOM.GEOM_Object, containing the result shape.
8026 # Example: see GEOM_Spanner.py
8027 DirFace1U,DirFace2U,NbTimesU,DirFace1V,DirFace2V,NbTimesV,Parameters = ParseParameters(
8028 DirFace1U,DirFace2U,NbTimesU,DirFace1V,DirFace2V,NbTimesV)
8029 anObj = self.BlocksOp.MakeMultiTransformation2D(Block, DirFace1U, DirFace2U, NbTimesU,
8030 DirFace1V, DirFace2V, NbTimesV)
8031 RaiseIfFailed("MakeMultiTransformation2D", self.BlocksOp)
8032 anObj.SetParameters(Parameters)
8035 ## Build all possible propagation groups.
8036 # Propagation group is a set of all edges, opposite to one (main)
8037 # edge of this group directly or through other opposite edges.
8038 # Notion of Opposite Edge make sence only on quadrangle face.
8039 # @param theShape Shape to build propagation groups on.
8040 # @return List of GEOM.GEOM_Object, each of them is a propagation group.
8042 # @ref swig_Propagate "Example"
8043 def Propagate(self,theShape):
8045 Build all possible propagation groups.
8046 Propagation group is a set of all edges, opposite to one (main)
8047 edge of this group directly or through other opposite edges.
8048 Notion of Opposite Edge make sence only on quadrangle face.
8051 theShape Shape to build propagation groups on.
8054 List of GEOM.GEOM_Object, each of them is a propagation group.
8056 # Example: see GEOM_TestOthers.py
8057 listChains = self.BlocksOp.Propagate(theShape)
8058 RaiseIfFailed("Propagate", self.BlocksOp)
8061 # end of l3_blocks_op
8064 ## @addtogroup l3_groups
8067 ## Creates a new group which will store sub-shapes of theMainShape
8068 # @param theMainShape is a GEOM object on which the group is selected
8069 # @param theShapeType defines a shape type of the group (see GEOM::shape_type)
8070 # @return a newly created GEOM group
8072 # @ref tui_working_with_groups_page "Example 1"
8073 # \n @ref swig_CreateGroup "Example 2"
8074 def CreateGroup(self,theMainShape, theShapeType):
8076 Creates a new group which will store sub-shapes of theMainShape
8079 theMainShape is a GEOM object on which the group is selected
8080 theShapeType defines a shape type of the group:"COMPOUND", "COMPSOLID",
8081 "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX", "SHAPE".
8084 a newly created GEOM group
8087 group = geompy.CreateGroup(Box, geompy.ShapeType["FACE"])
8090 # Example: see GEOM_TestOthers.py
8091 anObj = self.GroupOp.CreateGroup(theMainShape, theShapeType)
8092 RaiseIfFailed("CreateGroup", self.GroupOp)
8095 ## Adds a sub-object with ID theSubShapeId to the group
8096 # @param theGroup is a GEOM group to which the new sub-shape is added
8097 # @param theSubShapeID is a sub-shape ID in the main object.
8098 # \note Use method GetSubShapeID() to get an unique ID of the sub-shape
8100 # @ref tui_working_with_groups_page "Example"
8101 def AddObject(self,theGroup, theSubShapeID):
8103 Adds a sub-object with ID theSubShapeId to the group
8106 theGroup is a GEOM group to which the new sub-shape is added
8107 theSubShapeID is a sub-shape ID in the main object.
8110 Use method GetSubShapeID() to get an unique ID of the sub-shape
8112 # Example: see GEOM_TestOthers.py
8113 self.GroupOp.AddObject(theGroup, theSubShapeID)
8114 if self.GroupOp.GetErrorCode() != "PAL_ELEMENT_ALREADY_PRESENT":
8115 RaiseIfFailed("AddObject", self.GroupOp)
8119 ## Removes a sub-object with ID \a theSubShapeId from the group
8120 # @param theGroup is a GEOM group from which the new sub-shape is removed
8121 # @param theSubShapeID is a sub-shape ID in the main object.
8122 # \note Use method GetSubShapeID() to get an unique ID of the sub-shape
8124 # @ref tui_working_with_groups_page "Example"
8125 def RemoveObject(self,theGroup, theSubShapeID):
8127 Removes a sub-object with ID theSubShapeId from the group
8130 theGroup is a GEOM group from which the new sub-shape is removed
8131 theSubShapeID is a sub-shape ID in the main object.
8134 Use method GetSubShapeID() to get an unique ID of the sub-shape
8136 # Example: see GEOM_TestOthers.py
8137 self.GroupOp.RemoveObject(theGroup, theSubShapeID)
8138 RaiseIfFailed("RemoveObject", self.GroupOp)
8141 ## Adds to the group all the given shapes. No errors, if some shapes are alredy included.
8142 # @param theGroup is a GEOM group to which the new sub-shapes are added.
8143 # @param theSubShapes is a list of sub-shapes to be added.
8145 # @ref tui_working_with_groups_page "Example"
8146 def UnionList (self,theGroup, theSubShapes):
8148 Adds to the group all the given shapes. No errors, if some shapes are alredy included.
8151 theGroup is a GEOM group to which the new sub-shapes are added.
8152 theSubShapes is a list of sub-shapes to be added.
8154 # Example: see GEOM_TestOthers.py
8155 self.GroupOp.UnionList(theGroup, theSubShapes)
8156 RaiseIfFailed("UnionList", self.GroupOp)
8159 ## Adds to the group all the given shapes. No errors, if some shapes are alredy included.
8160 # @param theGroup is a GEOM group to which the new sub-shapes are added.
8161 # @param theSubShapes is a list of indices of sub-shapes to be added.
8163 # @ref swig_UnionIDs "Example"
8164 def UnionIDs(self,theGroup, theSubShapes):
8166 Adds to the group all the given shapes. No errors, if some shapes are alredy included.
8169 theGroup is a GEOM group to which the new sub-shapes are added.
8170 theSubShapes is a list of indices of sub-shapes to be added.
8172 # Example: see GEOM_TestOthers.py
8173 self.GroupOp.UnionIDs(theGroup, theSubShapes)
8174 RaiseIfFailed("UnionIDs", self.GroupOp)
8177 ## Removes from the group all the given shapes. No errors, if some shapes are not included.
8178 # @param theGroup is a GEOM group from which the sub-shapes are removed.
8179 # @param theSubShapes is a list of sub-shapes to be removed.
8181 # @ref tui_working_with_groups_page "Example"
8182 def DifferenceList (self,theGroup, theSubShapes):
8184 Removes from the group all the given shapes. No errors, if some shapes are not included.
8187 theGroup is a GEOM group from which the sub-shapes are removed.
8188 theSubShapes is a list of sub-shapes to be removed.
8190 # Example: see GEOM_TestOthers.py
8191 self.GroupOp.DifferenceList(theGroup, theSubShapes)
8192 RaiseIfFailed("DifferenceList", self.GroupOp)
8195 ## Removes from the group all the given shapes. No errors, if some shapes are not included.
8196 # @param theGroup is a GEOM group from which the sub-shapes are removed.
8197 # @param theSubShapes is a list of indices of sub-shapes to be removed.
8199 # @ref swig_DifferenceIDs "Example"
8200 def DifferenceIDs(self,theGroup, theSubShapes):
8202 Removes from the group all the given shapes. No errors, if some shapes are not included.
8205 theGroup is a GEOM group from which the sub-shapes are removed.
8206 theSubShapes is a list of indices of sub-shapes to be removed.
8208 # Example: see GEOM_TestOthers.py
8209 self.GroupOp.DifferenceIDs(theGroup, theSubShapes)
8210 RaiseIfFailed("DifferenceIDs", self.GroupOp)
8213 ## Returns a list of sub-objects ID stored in the group
8214 # @param theGroup is a GEOM group for which a list of IDs is requested
8216 # @ref swig_GetObjectIDs "Example"
8217 def GetObjectIDs(self,theGroup):
8219 Returns a list of sub-objects ID stored in the group
8222 theGroup is a GEOM group for which a list of IDs is requested
8224 # Example: see GEOM_TestOthers.py
8225 ListIDs = self.GroupOp.GetObjects(theGroup)
8226 RaiseIfFailed("GetObjects", self.GroupOp)
8229 ## Returns a type of sub-objects stored in the group
8230 # @param theGroup is a GEOM group which type is returned.
8232 # @ref swig_GetType "Example"
8233 def GetType(self,theGroup):
8235 Returns a type of sub-objects stored in the group
8238 theGroup is a GEOM group which type is returned.
8240 # Example: see GEOM_TestOthers.py
8241 aType = self.GroupOp.GetType(theGroup)
8242 RaiseIfFailed("GetType", self.GroupOp)
8245 ## Convert a type of geom object from id to string value
8246 # @param theId is a GEOM obect type id.
8247 # @return type of geom object (POINT, VECTOR, PLANE, LINE, TORUS, ... )
8248 # @ref swig_GetType "Example"
8249 def ShapeIdToType(self, theId):
8251 Convert a type of geom object from id to string value
8254 theId is a GEOM obect type id.
8257 type of geom object (POINT, VECTOR, PLANE, LINE, TORUS, ... )
8332 return "FREE_BOUNDS"
8340 return "THRUSECTIONS"
8342 return "COMPOUNDFILTER"
8344 return "SHAPES_ON_SHAPE"
8346 return "ELLIPSE_ARC"
8355 return "Shape Id not exist."
8357 ## Returns a main shape associated with the group
8358 # @param theGroup is a GEOM group for which a main shape object is requested
8359 # @return a GEOM object which is a main shape for theGroup
8361 # @ref swig_GetMainShape "Example"
8362 def GetMainShape(self,theGroup):
8364 Returns a main shape associated with the group
8367 theGroup is a GEOM group for which a main shape object is requested
8370 a GEOM object which is a main shape for theGroup
8372 Example of usage: BoxCopy = geompy.GetMainShape(CreateGroup)
8374 # Example: see GEOM_TestOthers.py
8375 anObj = self.GroupOp.GetMainShape(theGroup)
8376 RaiseIfFailed("GetMainShape", self.GroupOp)
8379 ## Create group of edges of theShape, whose length is in range [min_length, max_length].
8380 # If include_min/max == 0, edges with length == min/max_length will not be included in result.
8381 # @param theShape given shape (see GEOM.GEOM_Object)
8382 # @param min_length minimum length of edges of theShape
8383 # @param max_length maximum length of edges of theShape
8384 # @param include_max indicating if edges with length == max_length should be included in result, 1-yes, 0-no (default=1)
8385 # @param include_min indicating if edges with length == min_length should be included in result, 1-yes, 0-no (default=1)
8386 # @return a newly created GEOM group of edges
8387 # @@ref swig_todo "Example"
8388 def GetEdgesByLength (self, theShape, min_length, max_length, include_min = 1, include_max = 1):
8390 Create group of edges of theShape, whose length is in range [min_length, max_length].
8391 If include_min/max == 0, edges with length == min/max_length will not be included in result.
8394 theShape given shape
8395 min_length minimum length of edges of theShape
8396 max_length maximum length of edges of theShape
8397 include_max indicating if edges with length == max_length should be included in result, 1-yes, 0-no (default=1)
8398 include_min indicating if edges with length == min_length should be included in result, 1-yes, 0-no (default=1)
8401 a newly created GEOM group of edges.
8403 edges = self.SubShapeAll(theShape, ShapeType["EDGE"])
8406 Props = self.BasicProperties(edge)
8407 if min_length <= Props[0] and Props[0] <= max_length:
8408 if (not include_min) and (min_length == Props[0]):
8411 if (not include_max) and (Props[0] == max_length):
8414 edges_in_range.append(edge)
8416 if len(edges_in_range) <= 0:
8417 print "No edges found by given criteria"
8420 group_edges = self.CreateGroup(theShape, ShapeType["EDGE"])
8421 self.UnionList(group_edges, edges_in_range)
8425 ## Create group of edges of selected shape, whose length is in range [min_length, max_length].
8426 # If include_min/max == 0, edges with length == min/max_length will not be included in result.
8427 # @param min_length minimum length of edges of selected shape
8428 # @param max_length maximum length of edges of selected shape
8429 # @param include_max indicating if edges with length == max_length should be included in result, 1-yes, 0-no (default=1)
8430 # @param include_min indicating if edges with length == min_length should be included in result, 1-yes, 0-no (default=1)
8431 # @return a newly created GEOM group of edges
8432 # @ref swig_todo "Example"
8433 def SelectEdges (self, min_length, max_length, include_min = 1, include_max = 1):
8435 Create group of edges of selected shape, whose length is in range [min_length, max_length].
8436 If include_min/max == 0, edges with length == min/max_length will not be included in result.
8439 min_length minimum length of edges of selected shape
8440 max_length maximum length of edges of selected shape
8441 include_max indicating if edges with length == max_length should be included in result, 1-yes, 0-no (default=1)
8442 include_min indicating if edges with length == min_length should be included in result, 1-yes, 0-no (default=1)
8445 a newly created GEOM group of edges.
8447 nb_selected = sg.SelectedCount()
8449 print "Select a shape before calling this function, please."
8452 print "Only one shape must be selected"
8455 id_shape = sg.getSelected(0)
8456 shape = IDToObject( id_shape )
8458 group_edges = self.GetEdgesByLength(shape, min_length, max_length, include_min, include_max)
8462 if include_min: left_str = " <= "
8463 if include_max: right_str = " <= "
8465 self.addToStudyInFather(shape, group_edges, "Group of edges with " + `min_length`
8466 + left_str + "length" + right_str + `max_length`)
8468 sg.updateObjBrowser(1)
8475 ## @addtogroup l4_advanced
8478 ## Create a T-shape object with specified caracteristics for the main
8479 # and the incident pipes (radius, width, half-length).
8480 # The extremities of the main pipe are located on junctions points P1 and P2.
8481 # The extremity of the incident pipe is located on junction point P3.
8482 # If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8483 # the main plane of the T-shape is XOY.
8484 # @param theR1 Internal radius of main pipe
8485 # @param theW1 Width of main pipe
8486 # @param theL1 Half-length of main pipe
8487 # @param theR2 Internal radius of incident pipe (R2 < R1)
8488 # @param theW2 Width of incident pipe (R2+W2 < R1+W1)
8489 # @param theL2 Half-length of incident pipe
8490 # @param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8491 # @param theP1 1st junction point of main pipe
8492 # @param theP2 2nd junction point of main pipe
8493 # @param theP3 Junction point of incident pipe
8494 # @return List of GEOM.GEOM_Object, containing the created shape and propagation groups.
8496 # @ref tui_creation_pipetshape "Example"
8497 def MakePipeTShape(self, theR1, theW1, theL1, theR2, theW2, theL2, theHexMesh=True, theP1=None, theP2=None, theP3=None):
8499 Create a T-shape object with specified caracteristics for the main
8500 and the incident pipes (radius, width, half-length).
8501 The extremities of the main pipe are located on junctions points P1 and P2.
8502 The extremity of the incident pipe is located on junction point P3.
8503 If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8504 the main plane of the T-shape is XOY.
8507 theR1 Internal radius of main pipe
8508 theW1 Width of main pipe
8509 theL1 Half-length of main pipe
8510 theR2 Internal radius of incident pipe (R2 < R1)
8511 theW2 Width of incident pipe (R2+W2 < R1+W1)
8512 theL2 Half-length of incident pipe
8513 theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8514 theP1 1st junction point of main pipe
8515 theP2 2nd junction point of main pipe
8516 theP3 Junction point of incident pipe
8519 List of GEOM_Object, containing the created shape and propagation groups.
8522 # create PipeTShape object
8523 pipetshape = geompy.MakePipeTShape(80.0, 20.0, 200.0, 50.0, 20.0, 200.0)
8524 # create PipeTShape object with position
8525 pipetshape_position = geompy.MakePipeTShape(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, True, P1, P2, P3)
8527 theR1, theW1, theL1, theR2, theW2, theL2, Parameters = ParseParameters(theR1, theW1, theL1, theR2, theW2, theL2)
8528 if (theP1 and theP2 and theP3):
8529 anObj = self.AdvOp.MakePipeTShapeWithPosition(theR1, theW1, theL1, theR2, theW2, theL2, theHexMesh, theP1, theP2, theP3)
8531 anObj = self.AdvOp.MakePipeTShape(theR1, theW1, theL1, theR2, theW2, theL2, theHexMesh)
8532 RaiseIfFailed("MakePipeTShape", self.AdvOp)
8533 if Parameters: anObj[0].SetParameters(Parameters)
8536 ## Create a T-shape object with chamfer and with specified caracteristics for the main
8537 # and the incident pipes (radius, width, half-length). The chamfer is
8538 # created on the junction of the pipes.
8539 # The extremities of the main pipe are located on junctions points P1 and P2.
8540 # The extremity of the incident pipe is located on junction point P3.
8541 # If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8542 # the main plane of the T-shape is XOY.
8543 # @param theR1 Internal radius of main pipe
8544 # @param theW1 Width of main pipe
8545 # @param theL1 Half-length of main pipe
8546 # @param theR2 Internal radius of incident pipe (R2 < R1)
8547 # @param theW2 Width of incident pipe (R2+W2 < R1+W1)
8548 # @param theL2 Half-length of incident pipe
8549 # @param theH Height of the chamfer.
8550 # @param theW Width of the chamfer.
8551 # @param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8552 # @param theP1 1st junction point of main pipe
8553 # @param theP2 2nd junction point of main pipe
8554 # @param theP3 Junction point of incident pipe
8555 # @return List of GEOM.GEOM_Object, containing the created shape and propagation groups.
8557 # @ref tui_creation_pipetshape "Example"
8558 def MakePipeTShapeChamfer(self, theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, theHexMesh=True, theP1=None, theP2=None, theP3=None):
8560 Create a T-shape object with chamfer and with specified caracteristics for the main
8561 and the incident pipes (radius, width, half-length). The chamfer is
8562 created on the junction of the pipes.
8563 The extremities of the main pipe are located on junctions points P1 and P2.
8564 The extremity of the incident pipe is located on junction point P3.
8565 If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8566 the main plane of the T-shape is XOY.
8569 theR1 Internal radius of main pipe
8570 theW1 Width of main pipe
8571 theL1 Half-length of main pipe
8572 theR2 Internal radius of incident pipe (R2 < R1)
8573 theW2 Width of incident pipe (R2+W2 < R1+W1)
8574 theL2 Half-length of incident pipe
8575 theH Height of the chamfer.
8576 theW Width of the chamfer.
8577 theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8578 theP1 1st junction point of main pipe
8579 theP2 2nd junction point of main pipe
8580 theP3 Junction point of incident pipe
8583 List of GEOM_Object, containing the created shape and propagation groups.
8586 # create PipeTShape with chamfer object
8587 pipetshapechamfer = geompy.MakePipeTShapeChamfer(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 20.0, 20.0)
8588 # create PipeTShape with chamfer object with position
8589 pipetshapechamfer_position = geompy.MakePipeTShapeChamfer(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 20.0, 20.0, True, P1, P2, P3)
8591 theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, Parameters = ParseParameters(theR1, theW1, theL1, theR2, theW2, theL2, theH, theW)
8592 if (theP1 and theP2 and theP3):
8593 anObj = self.AdvOp.MakePipeTShapeChamferWithPosition(theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, theHexMesh, theP1, theP2, theP3)
8595 anObj = self.AdvOp.MakePipeTShapeChamfer(theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, theHexMesh)
8596 RaiseIfFailed("MakePipeTShapeChamfer", self.AdvOp)
8597 if Parameters: anObj[0].SetParameters(Parameters)
8600 ## Create a T-shape object with fillet and with specified caracteristics for the main
8601 # and the incident pipes (radius, width, half-length). The fillet is
8602 # created on the junction of the pipes.
8603 # The extremities of the main pipe are located on junctions points P1 and P2.
8604 # The extremity of the incident pipe is located on junction point P3.
8605 # If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8606 # the main plane of the T-shape is XOY.
8607 # @param theR1 Internal radius of main pipe
8608 # @param theW1 Width of main pipe
8609 # @param theL1 Half-length of main pipe
8610 # @param theR2 Internal radius of incident pipe (R2 < R1)
8611 # @param theW2 Width of incident pipe (R2+W2 < R1+W1)
8612 # @param theL2 Half-length of incident pipe
8613 # @param theRF Radius of curvature of fillet.
8614 # @param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8615 # @param theP1 1st junction point of main pipe
8616 # @param theP2 2nd junction point of main pipe
8617 # @param theP3 Junction point of incident pipe
8618 # @return List of GEOM.GEOM_Object, containing the created shape and propagation groups.
8620 # @ref tui_creation_pipetshape "Example"
8621 def MakePipeTShapeFillet(self, theR1, theW1, theL1, theR2, theW2, theL2, theRF, theHexMesh=True, theP1=None, theP2=None, theP3=None):
8623 Create a T-shape object with fillet and with specified caracteristics for the main
8624 and the incident pipes (radius, width, half-length). The fillet is
8625 created on the junction of the pipes.
8626 The extremities of the main pipe are located on junctions points P1 and P2.
8627 The extremity of the incident pipe is located on junction point P3.
8630 If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8631 the main plane of the T-shape is XOY.
8632 theR1 Internal radius of main pipe
8633 theW1 Width of main pipe
8634 heL1 Half-length of main pipe
8635 theR2 Internal radius of incident pipe (R2 < R1)
8636 theW2 Width of incident pipe (R2+W2 < R1+W1)
8637 theL2 Half-length of incident pipe
8638 theRF Radius of curvature of fillet.
8639 theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8640 theP1 1st junction point of main pipe
8641 theP2 2nd junction point of main pipe
8642 theP3 Junction point of incident pipe
8645 List of GEOM_Object, containing the created shape and propagation groups.
8648 # create PipeTShape with fillet object
8649 pipetshapefillet = geompy.MakePipeTShapeFillet(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 5.0)
8650 # create PipeTShape with fillet object with position
8651 pipetshapefillet_position = geompy.MakePipeTShapeFillet(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 5.0, True, P1, P2, P3)
8654 theR1, theW1, theL1, theR2, theW2, theL2, theRF, Parameters = ParseParameters(theR1, theW1, theL1, theR2, theW2, theL2, theRF)
8655 if (theP1 and theP2 and theP3):
8656 anObj = self.AdvOp.MakePipeTShapeFilletWithPosition(theR1, theW1, theL1, theR2, theW2, theL2, theRF, theHexMesh, theP1, theP2, theP3)
8658 anObj = self.AdvOp.MakePipeTShapeFillet(theR1, theW1, theL1, theR2, theW2, theL2, theRF, theHexMesh)
8659 RaiseIfFailed("MakePipeTShapeFillet", self.AdvOp)
8660 if Parameters: anObj[0].SetParameters(Parameters)
8663 ## This function allows creating a disk already divided into blocks. It
8664 # can be used to create divided pipes for later meshing in hexaedra.
8665 # @param theR Radius of the disk
8666 # @param theOrientation Orientation of the plane on which the disk will be built
8667 # 1 = XOY, 2 = OYZ, 3 = OZX
8668 # @param thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
8669 # @return New GEOM_Object, containing the created shape.
8671 # @ref tui_creation_divideddisk "Example"
8672 def MakeDividedDisk(self, theR, theOrientation, thePattern ):
8673 theR, Parameters = ParseParameters(theR)
8674 anObj = self.AdvOp.MakeDividedDisk(theR, 67.0, theOrientation, thePattern)
8675 RaiseIfFailed("MakeDividedDisk", self.AdvOp)
8676 if Parameters: anObj.SetParameters(Parameters)
8679 ## This function allows creating a disk already divided into blocks. It
8680 # can be used to create divided pipes for later meshing in hexaedra.
8681 # @param theCenter Center of the disk
8682 # @param theVector Normal vector to the plane of the created disk
8683 # @param theRadius Radius of the disk
8684 # @param thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
8685 # @return New GEOM_Object, containing the created shape.
8687 # @ref tui_creation_divideddisk "Example"
8688 def MakeDividedDiskPntVecR(self, theCenter, theVector, theRadius, thePattern):
8689 theRadius, Parameters = ParseParameters(theRadius)
8690 anObj = self.AdvOp.MakeDividedDiskPntVecR(theCenter, theVector, theRadius, 67.0, thePattern)
8691 RaiseIfFailed("MakeDividedDiskPntVecR", self.AdvOp)
8692 if Parameters: anObj.SetParameters(Parameters)
8695 ## Builds a cylinder prepared for hexa meshes
8696 # @param theR Radius of the cylinder
8697 # @param theH Height of the cylinder
8698 # @param thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
8699 # @return New GEOM_Object, containing the created shape.
8701 # @ref tui_creation_dividedcylinder "Example"
8702 def MakeDividedCylinder(self, theR, theH, thePattern):
8703 theR, theH, Parameters = ParseParameters(theR, theH)
8704 anObj = self.AdvOp.MakeDividedCylinder(theR, theH, thePattern)
8705 RaiseIfFailed("MakeDividedCylinder", self.AdvOp)
8706 if Parameters: anObj.SetParameters(Parameters)
8709 #@@ insert new functions before this line @@ do not remove this line @@#
8711 # end of l4_advanced
8714 ## Create a copy of the given object
8716 # @param theOriginal geometry object for copy
8717 # @return unique object identifier
8718 # @ingroup l1_geompy_auxiliary
8719 # @ref swig_MakeCopy "Example"
8720 def MakeCopy(self,theOriginal):
8722 Create a copy of the given object
8725 theOriginal geometry object for copy
8728 unique object identifier
8730 Example of usage: Copy = geompy.MakeCopy(Box)
8732 # Example: see GEOM_TestAll.py
8733 anObj = self.InsertOp.MakeCopy(theOriginal)
8734 RaiseIfFailed("MakeCopy", self.InsertOp)
8737 ## Add Path to load python scripts from
8738 # @param Path a path to load python scripts from
8739 # @ingroup l1_geompy_auxiliary
8740 def addPath(self,Path):
8742 Add Path to load python scripts from
8745 Path a path to load python scripts from
8747 if (sys.path.count(Path) < 1):
8748 sys.path.append(Path)
8752 ## Load marker texture from the file
8753 # @param Path a path to the texture file
8754 # @return unique texture identifier
8755 # @ingroup l1_geompy_auxiliary
8756 def LoadTexture(self, Path):
8758 Load marker texture from the file
8761 Path a path to the texture file
8764 unique texture identifier
8766 # Example: see GEOM_TestAll.py
8767 ID = self.InsertOp.LoadTexture(Path)
8768 RaiseIfFailed("LoadTexture", self.InsertOp)
8771 ## Get entry of the object
8772 # @param obj geometry object
8773 # @return unique object identifier
8774 # @ingroup l1_geompy_auxiliary
8775 def getObjectID(self, obj):
8777 Get entry of the object
8783 unique object identifier
8786 entry = salome.ObjectToID(obj)
8787 if entry is not None:
8788 lst = entry.split(":")
8790 ID = lst[-1] # -1 means last item in the list
8796 ## Add marker texture. @a Width and @a Height parameters
8797 # specify width and height of the texture in pixels.
8798 # If @a RowData is @c True, @a Texture parameter should represent texture data
8799 # packed into the byte array. If @a RowData is @c False (default), @a Texture
8800 # parameter should be unpacked string, in which '1' symbols represent opaque
8801 # pixels and '0' represent transparent pixels of the texture bitmap.
8803 # @param Width texture width in pixels
8804 # @param Height texture height in pixels
8805 # @param Texture texture data
8806 # @param RowData if @c True, @a Texture data are packed in the byte stream
8807 # @return unique texture identifier
8808 # @ingroup l1_geompy_auxiliary
8809 def AddTexture(self, Width, Height, Texture, RowData=False):
8811 Add marker texture. Width and Height parameters
8812 specify width and height of the texture in pixels.
8813 If RowData is True, Texture parameter should represent texture data
8814 packed into the byte array. If RowData is False (default), Texture
8815 parameter should be unpacked string, in which '1' symbols represent opaque
8816 pixels and '0' represent transparent pixels of the texture bitmap.
8819 Width texture width in pixels
8820 Height texture height in pixels
8821 Texture texture data
8822 RowData if True, Texture data are packed in the byte stream
8825 return unique texture identifier
8827 if not RowData: Texture = PackData(Texture)
8828 ID = self.InsertOp.AddTexture(Width, Height, Texture)
8829 RaiseIfFailed("AddTexture", self.InsertOp)
8833 #Register the new proxy for GEOM_Gen
8834 omniORB.registerObjref(GEOM._objref_GEOM_Gen._NP_RepositoryId, geompyDC)