src/GEOM_SWIG/geompyDC.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   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.
   8 #
   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.
  13 #
  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
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 #  File   : geompy.py
  21 #  Author : Paul RASCLE, EDF
  22 #  Module : GEOM
  23
  24 """
  25     \namespace geompy
  26     \brief Module geompy
  27 """
  28
  29 ## @defgroup l1_geompy_auxiliary Auxiliary data structures and methods
  30
  31 ## @defgroup l1_geompy_purpose   All package methods, grouped by their purpose
  32 ## @{
  33 ##   @defgroup l2_import_export Importing/exporting geometrical objects
  34 ##   @defgroup l2_creating      Creating geometrical objects
  35 ##   @{
  36 ##     @defgroup l3_basic_go      Creating Basic Geometric Objects
  37 ##     @{
  38 ##       @defgroup l4_curves        Creating Curves
  39
  40 ##     @}
  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
  45 ##     @{
  46 ##       @defgroup l4_blocks_measure Check and Improve
  47
  48 ##     @}
  49 ##     @defgroup l3_sketcher      Sketcher
  50 ##     @defgroup l3_advanced      Creating Advanced Geometrical Objects
  51 ##     @{
  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
  57
  58 ##     @}
  59
  60 ##   @}
  61 ##   @defgroup l2_transforming  Transforming geometrical objects
  62 ##   @{
  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
  70
  71 ##   @}
  72 ##   @defgroup l2_measure       Using measurement tools
  73
  74 ## @}
  75
  76 import salome
  77 salome.salome_init()
  78 from salome import *
  79
  80 from salome_notebook import *
  81
  82 import GEOM
  83 import math
  84 import os
  85
  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}
  90
  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()
  96
  97 ## Return list of variables value from salome notebook
  98 ## @ingroup l1_geompy_auxiliary
  99 def ParseParameters(*parameters):
 100     Result = []
 101     StringResult = []
 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(":")
 108                 pass
 109             pass
 110         else:
 111             if isinstance(parameter,str):
 112                 if notebook.isVariable(parameter):
 113                     Result.append(notebook.get(parameter))
 114                 else:
 115                     raise RuntimeError, "Variable with name '" + parameter + "' doesn't exist!!!"
 116                 pass
 117             else:
 118                 Result.append(parameter)
 119                 pass
 120             StringResult.append(str(parameter))
 121             pass
 122         pass
 123     if Result:
 124         Result.append(":".join(StringResult))
 125     else:
 126         Result = ":".join(StringResult)
 127     return Result
 128
 129 ## Return list of variables value from salome notebook
 130 ## @ingroup l1_geompy_auxiliary
 131 def ParseList(list):
 132     Result = []
 133     StringResult = ""
 134     for parameter in list:
 135         if isinstance(parameter,str) and notebook.isVariable(parameter):
 136             Result.append(str(notebook.get(parameter)))
 137             pass
 138         else:
 139             Result.append(str(parameter))
 140             pass
 141
 142         StringResult = StringResult + str(parameter)
 143         StringResult = StringResult + ":"
 144         pass
 145     StringResult = StringResult[:len(StringResult)-1]
 146     return Result, StringResult
 147
 148 ## Return list of variables value from salome notebook
 149 ## @ingroup l1_geompy_auxiliary
 150 def ParseSketcherCommand(command):
 151     Result = ""
 152     StringResult = ""
 153     sections = command.split(":")
 154     for section in sections:
 155         parameters = section.split(" ")
 156         paramIndex = 1
 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)) + " "
 162                     pass
 163                 else:
 164                     raise RuntimeError, "Variable with name '" + parameter + "' doesn't exist!!!"
 165                     pass
 166                 pass
 167             else:
 168                 Result = Result + str(parameter) + " "
 169                 pass
 170             if paramIndex > 1:
 171                 StringResult = StringResult + parameter
 172                 StringResult = StringResult + ":"
 173                 pass
 174             paramIndex = paramIndex + 1
 175             pass
 176         Result = Result[:len(Result)-1] + ":"
 177         pass
 178     Result = Result[:len(Result)-1]
 179     return Result, StringResult
 180
 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.
 184 ## For example,
 185 ## \code
 186 ## val = PackData("10001110") # val = 0xAE
 187 ## val = PackData("1")        # val = 0x80
 188 ## \endcode
 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
 192 def PackData(data):
 193     """
 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.
 197
 198     Parameters:
 199         data unpacked data - a string containing '1' and '0' symbols
 200
 201     Returns:
 202         data packed to the byte stream
 203
 204     Example of usage:
 205         val = PackData("10001110") # val = 0xAE
 206         val = PackData("1")        # val = 0x80
 207     """
 208     bytes = len(data)/8
 209     if len(data)%8: bytes += 1
 210     res = ""
 211     for b in range(bytes):
 212         d = data[b*8:(b+1)*8]
 213         val = 0
 214         for i in range(8):
 215             val *= 2
 216             if i < len(d):
 217                 if d[i] == "1": val += 1
 218                 elif d[i] != "0":
 219                     raise "Invalid symbol %s" % d[i]
 220                 pass
 221             pass
 222         res += chr(val)
 223         pass
 224     return res
 225
 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.
 231 ##
 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.
 234 ## For example,
 235 ## \code
 236 ## import geompy
 237 ## geompy.init_geom(salome.myStudy)
 238 ## texture = geompy.readtexture('mytexture.dat')
 239 ## texture = geompy.AddTexture(*texture)
 240 ## obj.SetMarkerTexture(texture)
 241 ## \endcode
 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):
 246     """
 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.
 254
 255     Parameters:
 256         fname texture file name
 257
 258     Returns:
 259         sequence of tree values: texture's width, height in pixels and its byte stream
 260
 261     Example of usage:
 262         import geompy
 263         geompy.init_geom(salome.myStudy)
 264         texture = geompy.readtexture('mytexture.dat')
 265         texture = geompy.AddTexture(*texture)
 266         obj.SetMarkerTexture(texture)
 267     """
 268     try:
 269         f = open(fname)
 270         lines = [ l.strip() for l in f.readlines()]
 271         f.close()
 272         maxlen = 0
 273         if lines: maxlen = max([len(x) for x in lines])
 274         lenbytes = maxlen/8
 275         if maxlen%8: lenbytes += 1
 276         bytedata=""
 277         for line in lines:
 278             if len(line)%8:
 279                 lenline = (len(line)/8+1)*8
 280                 pass
 281             else:
 282                 lenline = (len(line)/8)*8
 283                 pass
 284             for i in range(lenline/8):
 285                 byte=""
 286                 for j in range(8):
 287                     if i*8+j < len(line) and line[i*8+j] != "0": byte += "1"
 288                     else: byte += "0"
 289                     pass
 290                 bytedata += PackData(byte)
 291                 pass
 292             for i in range(lenline/8, lenbytes):
 293                 bytedata += PackData("0")
 294             pass
 295         return lenbytes*8, len(lines), bytedata
 296     except:
 297         pass
 298     return 0, 0, ""
 299
 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):
 305     """
 306     Returns a long value from enumeration type
 307     Can be used for CORBA enumerator types like geompy.ShapeType
 308
 309     Parameters:
 310         theItem enumeration type
 311     """
 312     ret = theItem
 313     if hasattr(theItem, "_v"): ret = theItem._v
 314     return ret
 315
 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]
 321 #
 322 #  - SHELL:       [info.CLOSED / info.UNCLOSED  nb_faces  nb_edges  nb_vertices]
 323 #
 324 #  - WIRE:        [info.CLOSED / info.UNCLOSED nb_edges  nb_vertices]
 325 #
 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]
 334 #
 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]
 345 #
 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]
 353 #
 354 #  - VERTEX:       [x  y  z]
 355 #  @ingroup l1_geompy_auxiliary
 356 kind = GEOM.GEOM_IKindOfShape
 357
 358 ## Information about closed/unclosed state of shell or wire
 359 #  @ingroup l1_geompy_auxiliary
 360 class info:
 361     """
 362     Information about closed/unclosed state of shell or wire
 363     """
 364     UNKNOWN  = 0
 365     CLOSED   = 1
 366     UNCLOSED = 2
 367
 368 class geompyDC(GEOM._objref_GEOM_Gen):
 369
 370         def __init__(self):
 371             GEOM._objref_GEOM_Gen.__init__(self)
 372             self.myBuilder = None
 373             self.myStudyId = 0
 374             self.father    = None
 375
 376             self.BasicOp  = None
 377             self.CurvesOp = None
 378             self.PrimOp   = None
 379             self.ShapesOp = None
 380             self.HealOp   = None
 381             self.InsertOp = None
 382             self.BoolOp   = None
 383             self.TrsfOp   = None
 384             self.LocalOp  = None
 385             self.MeasuOp  = None
 386             self.BlocksOp = None
 387             self.GroupOp  = None
 388             self.AdvOp    = None
 389             pass
 390
 391         ## @addtogroup l1_geompy_auxiliary
 392         ## @{
 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)
 407                 pass
 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)
 421             pass
 422
 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):
 426             """
 427             Dump component to the Python script
 428             This method overrides IDL function to allow default values for the parameters.
 429             """
 430             return GEOM._objref_GEOM_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile)
 431
 432         ## Get name for sub-shape aSubObj of shape aMainObj
 433         #
 434         # @ref swig_SubShapeName "Example"
 435         def SubShapeName(self,aSubObj, aMainObj):
 436             """
 437             Get name for sub-shape aSubObj of shape aMainObj
 438             """
 439             # Example: see GEOM_TestAll.py
 440
 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)
 447             return name
 448
 449         ## Publish in study aShape with name aName
 450         #
 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
 459         #
 460         #  @ref swig_all_addtostudy "Example"
 461         def addToStudy(self, aShape, aName, doRestoreSubShapes=False,
 462                        theArgs=[], theFindMethod=GEOM.FSM_GetInPlace, theInheritFirstArg=False):
 463             """
 464             Publish in study aShape with name aName
 465
 466             Parameters:
 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
 474
 475             Returns:
 476                 study entry of the published shape in form of string
 477
 478             Example of usage:
 479                 id_block1 = geompy.addToStudy(Block1, "Block 1")
 480             """
 481             # Example: see GEOM_TestAll.py
 482             try:
 483                 aSObject = self.AddInStudy(self.myStudy, aShape, aName, None)
 484                 if doRestoreSubShapes:
 485                     self.RestoreSubShapesSO(self.myStudy, aSObject, theArgs,
 486                                             theFindMethod, theInheritFirstArg, True )
 487             except:
 488                 print "addToStudy() failed"
 489                 return ""
 490             return aShape.GetStudyEntry()
 491
 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
 496         #
 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):
 500             """
 501             Publish in study aShape with name aName as sub-object of previously published aFather
 502
 503             Parameters:
 504                 aFather previously published object
 505                 aShape the shape to be published as sub-object of aFather
 506                 aName  the name for the shape
 507
 508             Returns:
 509                 study entry of the published shape in form of string
 510             """
 511             # Example: see GEOM_TestAll.py
 512             try:
 513                 aSObject = self.AddInStudy(self.myStudy, aShape, aName, aFather)
 514             except:
 515                 print "addToStudyInFather() failed"
 516                 return ""
 517             return aShape.GetStudyEntry()
 518
 519         ## Unpublish object in study
 520         #
 521         #  \param obj the object to be unpublished
 522         def hideInStudy(self, obj):
 523             """
 524             Unpublish object in study
 525
 526             Parameters:
 527                 obj the object to be unpublished
 528             """
 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)
 535                 pass
 536
 537         # end of l1_geompy_auxiliary
 538         ## @}
 539
 540         ## @addtogroup l3_restore_ss
 541         ## @{
 542
 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
 562         #
 563         #  @ref tui_restore_prs_params "Example"
 564         def RestoreSubShapes (self, theObject, theArgs=[], theFindMethod=GEOM.FSM_GetInPlace,
 565                               theInheritFirstArg=False, theAddPrefix=True):
 566             """
 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)
 569
 570             Parameters:
 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.
 587             Returns:
 588                 list of published sub-shapes
 589             """
 590             # Example: see GEOM_TestAll.py
 591             return self.RestoreSubShapesO(self.myStudy, theObject, theArgs,
 592                                           theFindMethod, theInheritFirstArg, theAddPrefix)
 593
 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
 613         #
 614         #  @ref tui_restore_prs_params "Example"
 615         def RestoreGivenSubShapes (self, theObject, theArgs=[], theFindMethod=GEOM.FSM_GetInPlace,
 616                                    theInheritFirstArg=False, theAddPrefix=True):
 617             """
 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)
 620
 621             Parameters:
 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.
 638
 639             Returns:
 640                 list of published sub-shapes
 641             """
 642             # Example: see GEOM_TestAll.py
 643             return self.RestoreGivenSubShapesO(self.myStudy, theObject, theArgs,
 644                                                theFindMethod, theInheritFirstArg, theAddPrefix)
 645
 646         # end of l3_restore_ss
 647         ## @}
 648
 649         ## @addtogroup l3_basic_go
 650         ## @{
 651
 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.
 657         #
 658         #  @ref tui_creation_point "Example"
 659         def MakeVertex(self, theX, theY, theZ):
 660             """
 661             Create point by three coordinates.
 662
 663             Parameters:
 664                 theX The X coordinate of the point.
 665                 theY The Y coordinate of the point.
 666                 theZ The Z coordinate of the point.
 667
 668             Returns:
 669                 New GEOM.GEOM_Object, containing the created point.
 670             """
 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)
 676             return anObj
 677
 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.
 685         #
 686         #  @ref tui_creation_point "Example"
 687         def MakeVertexWithRef(self,theReference, theX, theY, theZ):
 688             """
 689             Create a point, distant from the referenced point
 690             on the given distances along the coordinate axes.
 691
 692             Parameters:
 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.
 697
 698             Returns:
 699                 New GEOM.GEOM_Object, containing the created point.
 700             """
 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)
 706             return anObj
 707
 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.
 712         #
 713         #  @ref tui_creation_point "Example"
 714         def MakeVertexOnCurve(self,theRefCurve, theParameter):
 715             """
 716             Create a point, corresponding to the given parameter on the given curve.
 717
 718             Parameters:
 719                 theRefCurve The referenced curve.
 720                 theParameter Value of parameter on the referenced curve.
 721
 722             Returns:
 723                 New GEOM.GEOM_Object, containing the created point.
 724
 725             Example of usage:
 726                 p_on_arc = geompy.MakeVertexOnCurve(Arc, 0.25)
 727             """
 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)
 733             return anObj
 734
 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.
 741         #
 742         #  @ref tui_creation_point "Example"
 743         def MakeVertexOnCurveByCoord(self,theRefCurve, theX, theY, theZ):
 744             """
 745             Create a point by projection give coordinates on the given curve
 746
 747             Parameters:
 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
 752
 753             Returns:
 754                 New GEOM.GEOM_Object, containing the created point.
 755
 756             Example of usage:
 757                 p_on_arc3 = geompy.MakeVertexOnCurveByCoord(Arc, 100, -10, 10)
 758             """
 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)
 764             return anObj
 765
 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.
 772         #
 773         #  @ref tui_creation_point "Example"
 774         def MakeVertexOnCurveByLength(self, theRefCurve, theLength, theStartPoint = None):
 775             """
 776             Create a point, corresponding to the given length on the given curve.
 777
 778             Parameters:
 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.
 783
 784             Returns:
 785                 New GEOM.GEOM_Object, containing the created point.
 786             """
 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)
 792             return anObj
 793
 794         ## Create a point, corresponding to the given parameters on the
 795         #    given surface.
 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.
 800         #
 801         #  @ref swig_MakeVertexOnSurface "Example"
 802         def MakeVertexOnSurface(self, theRefSurf, theUParameter, theVParameter):
 803             """
 804             Create a point, corresponding to the given parameters on the
 805             given surface.
 806
 807             Parameters:
 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.
 811
 812             Returns:
 813                 New GEOM.GEOM_Object, containing the created point.
 814
 815             Example of usage:
 816                 p_on_face = geompy.MakeVertexOnSurface(Face, 0.1, 0.8) #(GEOM_Object, Double, Double)->GEOM_Object
 817             """
 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);
 823             return anObj
 824
 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.
 831         #
 832         #  @ref swig_MakeVertexOnSurfaceByCoord "Example"
 833         def MakeVertexOnSurfaceByCoord(self, theRefSurf, theX, theY, theZ):
 834             """
 835             Create a point by projection give coordinates on the given surface
 836
 837             Parameters:
 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
 842
 843             Returns:
 844                 New GEOM.GEOM_Object, containing the created point.
 845
 846             Example of usage:
 847                 p_on_face2 = geompy.MakeVertexOnSurfaceByCoord(Face, 0., 0., 0.) #(GEOM_Object, Double, Double, Double)->GEOM_Object
 848             """
 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);
 854             return anObj
 855
 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.
 859         #
 860         #  @ref swig_MakeVertexOnLinesIntersection "Example"
 861         def MakeVertexOnLinesIntersection(self, theRefLine1, theRefLine2):
 862             """
 863             Create a point on intersection of two lines.
 864
 865             Parameters:
 866                 theRefLine1, theRefLine2 The referenced lines.
 867
 868             Returns:
 869                 New GEOM.GEOM_Object, containing the created point.
 870             """
 871             # Example: see GEOM_TestAll.py
 872             anObj = self.BasicOp.MakePointOnLinesIntersection(theRefLine1, theRefLine2)
 873             RaiseIfFailed("MakePointOnLinesIntersection", self.BasicOp)
 874             return anObj
 875
 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.
 880         #
 881         #  @ref swig_MakeTangentOnCurve "Example"
 882         def MakeTangentOnCurve(self, theRefCurve, theParameter):
 883             """
 884             Create a tangent, corresponding to the given parameter on the given curve.
 885
 886             Parameters:
 887                 theRefCurve The referenced curve.
 888                 theParameter Value of parameter on the referenced curve.
 889
 890             Returns:
 891                 New GEOM.GEOM_Object, containing the created tangent.
 892
 893             Example of usage:
 894                 tan_on_arc = geompy.MakeTangentOnCurve(Arc, 0.7) #(GEOM_Object, Double)->GEOM_Object
 895             """
 896             anObj = self.BasicOp.MakeTangentOnCurve(theRefCurve, theParameter)
 897             RaiseIfFailed("MakeTangentOnCurve", self.BasicOp)
 898             return anObj
 899
 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.
 906         #
 907         #  @ref swig_MakeTangentPlaneOnFace "Example"
 908         def MakeTangentPlaneOnFace(self, theFace, theParameterU, theParameterV, theTrimSize):
 909             """
 910             Create a tangent plane, corresponding to the given parameter on the given face.
 911
 912             Parameters:
 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.
 917
 918            Returns:
 919                 New GEOM.GEOM_Object, containing the created tangent.
 920
 921            Example of usage:
 922                 an_on_face = geompy.MakeTangentPlaneOnFace(tan_extrusion, 0.7, 0.5, 150)
 923             """
 924             anObj = self.BasicOp.MakeTangentPlaneOnFace(theFace, theParameterU, theParameterV, theTrimSize)
 925             RaiseIfFailed("MakeTangentPlaneOnFace", self.BasicOp)
 926             return anObj
 927
 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.
 933         #
 934         #  @ref tui_creation_vector "Example"
 935         def MakeVectorDXDYDZ(self,theDX, theDY, theDZ):
 936             """
 937             Create a vector with the given components.
 938
 939             Parameters:
 940                 theDX X component of the vector.
 941                 theDY Y component of the vector.
 942                 theDZ Z component of the vector.
 943
 944             Returns:
 945                 New GEOM.GEOM_Object, containing the created vector.
 946             """
 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)
 952             return anObj
 953
 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.
 958         #
 959         #  @ref tui_creation_vector "Example"
 960         def MakeVector(self,thePnt1, thePnt2):
 961             """
 962             Create a vector between two points.
 963
 964             Parameters:
 965                 thePnt1 Start point for the vector.
 966                 thePnt2 End point for the vector.
 967
 968             Returns:
 969                 New GEOM.GEOM_Object, containing the created vector.
 970             """
 971             # Example: see GEOM_TestAll.py
 972             anObj = self.BasicOp.MakeVectorTwoPnt(thePnt1, thePnt2)
 973             RaiseIfFailed("MakeVectorTwoPnt", self.BasicOp)
 974             return anObj
 975
 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.
 981         #
 982         #  @ref tui_creation_line "Example"
 983         def MakeLine(self,thePnt, theDir):
 984             """
 985             Create a line, passing through the given point
 986             and parrallel to the given direction
 987
 988             Parameters:
 989                 thePnt Point. The resulting line will pass through it.
 990                 theDir Direction. The resulting line will be parallel to it.
 991
 992             Returns:
 993                 New GEOM.GEOM_Object, containing the created line.
 994             """
 995             # Example: see GEOM_TestAll.py
 996             anObj = self.BasicOp.MakeLine(thePnt, theDir)
 997             RaiseIfFailed("MakeLine", self.BasicOp)
 998             return anObj
 999
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.
1004         #
1005         #  @ref tui_creation_line "Example"
1006         def MakeLineTwoPnt(self,thePnt1, thePnt2):
1007             """
1008             Create a line, passing through the given points
1009
1010             Parameters:
1011                 thePnt1 First of two points, defining the line.
1012                 thePnt2 Second of two points, defining the line.
1013
1014             Returns:
1015                 New GEOM.GEOM_Object, containing the created line.
1016             """
1017             # Example: see GEOM_TestAll.py
1018             anObj = self.BasicOp.MakeLineTwoPnt(thePnt1, thePnt2)
1019             RaiseIfFailed("MakeLineTwoPnt", self.BasicOp)
1020             return anObj
1021
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.
1026         #
1027         #  @ref swig_MakeLineTwoFaces "Example"
1028         def MakeLineTwoFaces(self, theFace1, theFace2):
1029             """
1030             Create a line on two faces intersection.
1031
1032             Parameters:
1033                 theFace1 First of two faces, defining the line.
1034                 theFace2 Second of two faces, defining the line.
1035
1036             Returns:
1037                 New GEOM.GEOM_Object, containing the created line.
1038             """
1039             # Example: see GEOM_TestAll.py
1040             anObj = self.BasicOp.MakeLineTwoFaces(theFace1, theFace2)
1041             RaiseIfFailed("MakeLineTwoFaces", self.BasicOp)
1042             return anObj
1043
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.
1050         #
1051         #  @ref tui_creation_plane "Example"
1052         def MakePlane(self,thePnt, theVec, theTrimSize):
1053             """
1054             Create a plane, passing through the given point
1055             and normal to the given vector.
1056
1057             Parameters:
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.
1061
1062             Returns:
1063                 New GEOM.GEOM_Object, containing the created plane.
1064             """
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)
1070             return anObj
1071
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.
1078         #
1079         #  @ref tui_creation_plane "Example"
1080         def MakePlaneThreePnt(self,thePnt1, thePnt2, thePnt3, theTrimSize):
1081             """
1082             Create a plane, passing through the three given points
1083
1084             Parameters:
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.
1089
1090             Returns:
1091                 New GEOM.GEOM_Object, containing the created plane.
1092             """
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)
1098             return anObj
1099
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.
1104         #
1105         #  @ref tui_creation_plane "Example"
1106         def MakePlaneFace(self,theFace, theTrimSize):
1107             """
1108             Create a plane, similar to the existing one, but with another size of representing face.
1109
1110             Parameters:
1111                 theFace Referenced plane or LCS(Marker).
1112                 theTrimSize New half size of a side of quadrangle face, representing the plane.
1113
1114             Returns:
1115                 New GEOM.GEOM_Object, containing the created plane.
1116             """
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)
1122             return anObj
1123
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.
1130         #
1131         #  @ref tui_creation_plane "Example"
1132         def MakePlane2Vec(self,theVec1, theVec2, theTrimSize):
1133             """
1134             Create a plane, passing through the 2 vectors
1135             with center in a start point of the first vector.
1136
1137             Parameters:
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.
1141
1142             Returns:
1143                 New GEOM.GEOM_Object, containing the created plane.
1144             """
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)
1150             return anObj
1151
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.
1157         #
1158         #  @ref tui_creation_plane "Example"
1159         def MakePlaneLCS(self,theLCS, theTrimSize, theOrientation):
1160             """
1161             Create a plane, based on a Local coordinate system.
1162
1163            Parameters:
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)
1167
1168             Returns:
1169                 New GEOM.GEOM_Object, containing the created plane.
1170             """
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)
1176             return anObj
1177
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.
1183         #
1184         #  @ref swig_MakeMarker "Example"
1185         def MakeMarker(self, OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ):
1186             """
1187             Create a local coordinate system.
1188
1189             Parameters:
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
1193
1194             Returns:
1195                 New GEOM.GEOM_Object, containing the created coordinate system.
1196             """
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)
1202             return anObj
1203
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.
1207         #
1208         #  @ref tui_creation_lcs "Example"
1209         def MakeMarkerFromShape(self, theShape):
1210             """
1211             Create a local coordinate system from shape.
1212
1213             Parameters:
1214                 theShape The initial shape to detect the coordinate system.
1215
1216             Returns:
1217                 New GEOM.GEOM_Object, containing the created coordinate system.
1218             """
1219             anObj = self.BasicOp.MakeMarkerFromShape(theShape)
1220             RaiseIfFailed("MakeMarkerFromShape", self.BasicOp)
1221             return anObj
1222
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.
1228         #
1229         #  @ref tui_creation_lcs "Example"
1230         def MakeMarkerPntTwoVec(self, theOrigin, theXVec, theYVec):
1231             """
1232             Create a local coordinate system from point and two vectors.
1233
1234             Parameters:
1235                 theOrigin Point of coordinate system origin.
1236                 theXVec Vector of X direction
1237                 theYVec Vector of Y direction
1238
1239             Returns:
1240                 New GEOM.GEOM_Object, containing the created coordinate system.
1241
1242             """
1243             anObj = self.BasicOp.MakeMarkerPntTwoVec(theOrigin, theXVec, theYVec)
1244             RaiseIfFailed("MakeMarkerPntTwoVec", self.BasicOp)
1245             return anObj
1246
1247         # end of l3_basic_go
1248         ## @}
1249
1250         ## @addtogroup l4_curves
1251         ## @{
1252
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.
1258         #
1259         #  @ref swig_MakeArc "Example"
1260         def MakeArc(self,thePnt1, thePnt2, thePnt3):
1261             """
1262             Create an arc of circle, passing through three given points.
1263
1264             Parameters:
1265                 thePnt1 Start point of the arc.
1266                 thePnt2 Middle point of the arc.
1267                 thePnt3 End point of the arc.
1268
1269             Returns:
1270                 New GEOM.GEOM_Object, containing the created arc.
1271             """
1272             # Example: see GEOM_TestAll.py
1273             anObj = self.CurvesOp.MakeArc(thePnt1, thePnt2, thePnt3)
1274             RaiseIfFailed("MakeArc", self.CurvesOp)
1275             return anObj
1276
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.
1283         #
1284         #  @ref swig_MakeArc "Example"
1285         def MakeArcCenter(self, thePnt1, thePnt2, thePnt3, theSense=False):
1286             """
1287             Create an arc of circle from a center and 2 points.
1288
1289             Parameters:
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
1294
1295             Returns:
1296                 New GEOM.GEOM_Object, containing the created arc.
1297             """
1298             # Example: see GEOM_TestAll.py
1299             anObj = self.CurvesOp.MakeArcCenter(thePnt1, thePnt2, thePnt3, theSense)
1300             RaiseIfFailed("MakeArcCenter", self.CurvesOp)
1301             return anObj
1302
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.
1308         #
1309         #  @ref swig_MakeArc "Example"
1310         def MakeArcOfEllipse(self,theCenter, thePnt1, thePnt2):
1311             """
1312             Create an arc of ellipse, of center and two points.
1313
1314             Parameters:
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.
1318
1319             Returns:
1320                 New GEOM.GEOM_Object, containing the created arc.
1321             """
1322             # Example: see GEOM_TestAll.py
1323             anObj = self.CurvesOp.MakeArcOfEllipse(theCenter, thePnt1, thePnt2)
1324             RaiseIfFailed("MakeArcOfEllipse", self.CurvesOp)
1325             return anObj
1326
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.
1332         #
1333         #  @ref tui_creation_circle "Example"
1334         def MakeCircle(self, thePnt, theVec, theR):
1335             """
1336             Create a circle with given center, normal vector and radius.
1337
1338             Parameters:
1339                 thePnt Circle center.
1340                 theVec Vector, normal to the plane of the circle.
1341                 theR Circle radius.
1342
1343             Returns:
1344                 New GEOM.GEOM_Object, containing the created circle.
1345             """
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)
1351             return anObj
1352
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):
1359             """
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
1363
1364             Parameters:
1365                 theR Circle radius.
1366
1367             Returns:
1368                 New GEOM.GEOM_Object, containing the created circle.
1369             """
1370             anObj = self.CurvesOp.MakeCirclePntVecR(None, None, theR)
1371             RaiseIfFailed("MakeCirclePntVecR", self.CurvesOp)
1372             return anObj
1373
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.
1377         #
1378         #  @ref tui_creation_circle "Example"
1379         def MakeCircleThreePnt(self,thePnt1, thePnt2, thePnt3):
1380             """
1381             Create a circle, passing through three given points
1382
1383             Parameters:
1384                 thePnt1,thePnt2,thePnt3 Points, defining the circle.
1385
1386             Returns:
1387                 New GEOM.GEOM_Object, containing the created circle.
1388             """
1389             # Example: see GEOM_TestAll.py
1390             anObj = self.CurvesOp.MakeCircleThreePnt(thePnt1, thePnt2, thePnt3)
1391             RaiseIfFailed("MakeCircleThreePnt", self.CurvesOp)
1392             return anObj
1393
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.
1399         #
1400         #  @ref swig_MakeCircle "Example"
1401         def MakeCircleCenter2Pnt(self,thePnt1, thePnt2, thePnt3):
1402             """
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.
1406
1407             Parameters:
1408                 thePnt1,thePnt2,thePnt3 Points, defining the circle.
1409
1410             Returns:
1411                 New GEOM.GEOM_Object, containing the created circle.
1412             """
1413             # Example: see GEOM_example6.py
1414             anObj = self.CurvesOp.MakeCircleCenter2Pnt(thePnt1, thePnt2, thePnt3)
1415             RaiseIfFailed("MakeCircleCenter2Pnt", self.CurvesOp)
1416             return anObj
1417
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.
1425         #
1426         #  @ref tui_creation_ellipse "Example"
1427         def MakeEllipse(self, thePnt, theVec, theRMajor, theRMinor, theVecMaj=None):
1428             """
1429             Create an ellipse with given center, normal vector and radiuses.
1430
1431             Parameters:
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.
1437
1438             Returns:
1439                 New GEOM.GEOM_Object, containing the created ellipse.
1440             """
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)
1445             else:
1446                 anObj = self.CurvesOp.MakeEllipse(thePnt, theVec, theRMajor, theRMinor)
1447                 pass
1448             RaiseIfFailed("MakeEllipse", self.CurvesOp)
1449             anObj.SetParameters(Parameters)
1450             return anObj
1451
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):
1459             """
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
1463
1464             Parameters:
1465                 theRMajor Major ellipse radius.
1466                 theRMinor Minor ellipse radius.
1467
1468             Returns:
1469                 New GEOM.GEOM_Object, containing the created ellipse.
1470             """
1471             anObj = self.CurvesOp.MakeEllipse(None, None, theRMajor, theRMinor)
1472             RaiseIfFailed("MakeEllipse", self.CurvesOp)
1473             return anObj
1474
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.
1479         #
1480         #  @ref tui_creation_curve "Example"
1481         def MakePolyline(self, thePoints, theIsClosed=False):
1482             """
1483             Create a polyline on the set of points.
1484
1485             Parameters:
1486                 thePoints Sequence of points for the polyline.
1487                 theIsClosed If True, build a closed wire.
1488
1489             Returns:
1490                 New GEOM.GEOM_Object, containing the created polyline.
1491             """
1492             # Example: see GEOM_TestAll.py
1493             anObj = self.CurvesOp.MakePolyline(thePoints, theIsClosed)
1494             RaiseIfFailed("MakePolyline", self.CurvesOp)
1495             return anObj
1496
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.
1501         #
1502         #  @ref tui_creation_curve "Example"
1503         def MakeBezier(self, thePoints, theIsClosed=False):
1504             """
1505             Create bezier curve on the set of points.
1506
1507             Parameters:
1508                 thePoints Sequence of points for the bezier curve.
1509                 theIsClosed If True, build a closed curve.
1510
1511             Returns:
1512                 New GEOM.GEOM_Object, containing the created bezier curve.
1513             """
1514             # Example: see GEOM_TestAll.py
1515             anObj = self.CurvesOp.MakeSplineBezier(thePoints, theIsClosed)
1516             RaiseIfFailed("MakeSplineBezier", self.CurvesOp)
1517             return anObj
1518
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.
1525         #
1526         #  @ref tui_creation_curve "Example"
1527         def MakeInterpol(self, thePoints, theIsClosed=False, theDoReordering=False):
1528             """
1529             Create B-Spline curve on the set of points.
1530
1531             Parameters:
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.
1536
1537             Returns:
1538                 New GEOM.GEOM_Object, containing the created B-Spline curve.
1539             """
1540             # Example: see GEOM_TestAll.py
1541             anObj = self.CurvesOp.MakeSplineInterpolation(thePoints, theIsClosed, theDoReordering)
1542             RaiseIfFailed("MakeSplineInterpolation", self.CurvesOp)
1543             return anObj
1544
1545
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.
1556         #
1557         #  @ref tui_creation_curve "Example"
1558         def MakeCurveParametric(self, thexExpr, theyExpr, thezExpr,
1559                                 theParamMin, theParamMax, theParamStep, theCurveType, theNewMethod=False ):
1560             """
1561             Creates a curve using the parametric definition of the basic points.
1562
1563             Parameters:
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.
1573
1574             Returns:
1575                 New GEOM.GEOM_Object, containing the created curve.
1576             """
1577             theParamMin,theParamMax,theParamStep,Parameters = ParseParameters(theParamMin,theParamMax,theParamStep)
1578             if theNewMethod:
1579               anObj = self.CurvesOp.MakeCurveParametricNew(thexExpr,theyExpr,thezExpr,theParamMin,theParamMax,theParamStep,theCurveType)
1580             else:
1581               anObj = self.CurvesOp.MakeCurveParametric(thexExpr,theyExpr,thezExpr,theParamMin,theParamMax,theParamStep,theCurveType)
1582             RaiseIfFailed("MakeSplineInterpolation", self.CurvesOp)
1583             anObj.SetParameters(Parameters)
1584             return anObj
1585
1586
1587
1588         # end of l4_curves
1589         ## @}
1590
1591         ## @addtogroup l3_sketcher
1592         ## @{
1593
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:
1598         #
1599         #  "Sketcher[:F x1 y1]:CMD[:CMD[:CMD...]]"
1600         #
1601         #  Where:
1602         #  - x1, y1 are coordinates of the first sketcher point (zero by default),
1603         #  - CMD is one of
1604         #     - "R angle" : Set the direction by angle
1605         #     - "D dx dy" : Set the direction by DX & DY
1606         #     .
1607         #       \n
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
1613         #     .
1614         #       \n
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
1623         #     .
1624         #       \n
1625         #     - "WW" : Close Wire (to finish)
1626         #     - "WF" : Close Wire and build face (to finish)
1627         #     .
1628         #        \n
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)
1632         #     .
1633         #        \n
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
1638         #
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.
1644         #
1645         #  @ref tui_sketcher_page "Example"
1646         def MakeSketcher(self, theCommand, theWorkingPlane = [0,0,0, 0,0,1, 1,0,0]):
1647             """
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...]]"
1653             Where:
1654             - x1, y1 are coordinates of the first sketcher point (zero by default),
1655             - CMD is one of
1656                - "R angle" : Set the direction by angle
1657                - "D dx dy" : Set the direction by DX & DY
1658
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
1664
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
1673
1674                - "WW" : Close Wire (to finish)
1675                - "WF" : Close Wire and build face (to finish)
1676
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)
1680
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
1685
1686             Parameters:
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.
1691
1692             Returns:
1693                 New GEOM.GEOM_Object, containing the created wire.
1694             """
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)
1700             return anObj
1701
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.
1709         #
1710         #  @ref tui_sketcher_page "Example"
1711         def MakeSketcherOnPlane(self, theCommand, theWorkingPlane):
1712             """
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.
1716
1717             Parameters:
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.
1721
1722             Returns:
1723                 New GEOM.GEOM_Object, containing the created wire.
1724             """
1725             anObj = self.CurvesOp.MakeSketcherOnPlane(theCommand, theWorkingPlane)
1726             RaiseIfFailed("MakeSketcherOnPlane", self.CurvesOp)
1727             return anObj
1728
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,
1732         #                                                      passing from it.
1733         #  @return New GEOM.GEOM_Object, containing the created wire.
1734         #
1735         #  @ref tui_sketcher_page "Example"
1736         def Make3DSketcher(self, theCoordinates):
1737             """
1738             Create a sketcher wire, following the numerical description,
1739             passed through theCoordinates argument.
1740
1741             Parameters:
1742                 theCoordinates double values, defining points to create a wire,
1743                                passing from it.
1744
1745             Returns:
1746                 New GEOM_Object, containing the created wire.
1747             """
1748             theCoordinates,Parameters = ParseParameters(theCoordinates)
1749             anObj = self.CurvesOp.Make3DSketcher(theCoordinates)
1750             RaiseIfFailed("Make3DSketcher", self.CurvesOp)
1751             anObj.SetParameters(Parameters)
1752             return anObj
1753
1754         # end of l3_sketcher
1755         ## @}
1756
1757         ## @addtogroup l3_3d_primitives
1758         ## @{
1759
1760         ## Create a box by coordinates of two opposite vertices.
1761         #
1762         #  @param x1,y1,z1 double values, defining first point it.
1763         #  @param x2,y2,z2 double values, defining first point it.
1764         #
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):
1768             """
1769             Create a box by coordinates of two opposite vertices.
1770
1771             Parameters:
1772                 x1,y1,z1 double values, defining first point.
1773                 x2,y2,z2 double values, defining second point.
1774
1775             Returns:
1776                 New GEOM.GEOM_Object, containing the created box.
1777             """
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)
1782
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.
1790         #
1791         #  @ref tui_creation_box "Example"
1792         def MakeBoxDXDYDZ(self,theDX, theDY, theDZ):
1793             """
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).
1797
1798             Parameters:
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.
1802
1803             Returns:
1804                 New GEOM.GEOM_Object, containing the created box.
1805             """
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)
1811             return anObj
1812
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.
1818         #
1819         #  @ref tui_creation_box "Example"
1820         def MakeBoxTwoPnt(self,thePnt1, thePnt2):
1821             """
1822             Create a box with two specified opposite vertices,
1823             and with edges, parallel to the coordinate axes
1824
1825             Parameters:
1826                 thePnt1 First of two opposite vertices.
1827                 thePnt2 Second of two opposite vertices.
1828
1829             Returns:
1830                 New GEOM.GEOM_Object, containing the created box.
1831             """
1832             # Example: see GEOM_TestAll.py
1833             anObj = self.PrimOp.MakeBoxTwoPnt(thePnt1, thePnt2)
1834             RaiseIfFailed("MakeBoxTwoPnt", self.PrimOp)
1835             return anObj
1836
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.
1842         #
1843         #  @ref tui_creation_face "Example"
1844         def MakeFaceHW(self,theH, theW, theOrientation):
1845             """
1846             Create a face with specified dimensions with edges parallel to coordinate axes.
1847
1848             Parameters:
1849                 theH height of Face.
1850                 theW width of Face.
1851                 theOrientation face orientation: 1-OXY, 2-OYZ, 3-OZX
1852
1853             Returns:
1854                 New GEOM.GEOM_Object, containing the created face.
1855             """
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)
1861             return anObj
1862
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
1866         #  the face object.
1867         #  @param theH     Height (vertical size).
1868         #  @param theW     Width (horisontal size).
1869         #  @return New GEOM.GEOM_Object, containing the created face.
1870         #
1871         #  @ref tui_creation_face "Example"
1872         def MakeFaceObjHW(self, theObj, theH, theW):
1873             """
1874             Create a face from another plane and two sizes,
1875             vertical size and horisontal size.
1876
1877             Parameters:
1878                 theObj   Normale vector to the creating face or
1879                          the face object.
1880                 theH     Height (vertical size).
1881                 theW     Width (horisontal size).
1882
1883             Returns:
1884                 New GEOM_Object, containing the created face.
1885             """
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)
1891             return anObj
1892
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.
1898         #
1899         #  @ref tui_creation_disk "Example"
1900         def MakeDiskPntVecR(self,thePnt, theVec, theR):
1901             """
1902             Create a disk with given center, normal vector and radius.
1903
1904             Parameters:
1905                 thePnt Disk center.
1906                 theVec Vector, normal to the plane of the disk.
1907                 theR Disk radius.
1908
1909             Returns:
1910                 New GEOM.GEOM_Object, containing the created disk.
1911             """
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)
1917             return anObj
1918
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.
1922         #
1923         #  @ref tui_creation_disk "Example"
1924         def MakeDiskThreePnt(self,thePnt1, thePnt2, thePnt3):
1925             """
1926             Create a disk, passing through three given points
1927
1928             Parameters:
1929                 thePnt1,thePnt2,thePnt3 Points, defining the disk.
1930
1931             Returns:
1932                 New GEOM.GEOM_Object, containing the created disk.
1933             """
1934             # Example: see GEOM_TestAll.py
1935             anObj = self.PrimOp.MakeDiskThreePnt(thePnt1, thePnt2, thePnt3)
1936             RaiseIfFailed("MakeDiskThreePnt", self.PrimOp)
1937             return anObj
1938
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.
1943         #
1944         #  @ref tui_creation_face "Example"
1945         def MakeDiskR(self,theR, theOrientation):
1946             """
1947             Create a disk with specified dimensions along OX-OY coordinate axes.
1948
1949             Parameters:
1950                 theR Radius of Face.
1951                 theOrientation set the orientation belong axis OXY or OYZ or OZX
1952
1953             Returns:
1954                 New GEOM.GEOM_Object, containing the created disk.
1955
1956             Example of usage:
1957                 Disk3 = geompy.MakeDiskR(100., 1)   #(1 Doubles, 1 Int)->GEOM_Object
1958             """
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)
1964             return anObj
1965
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.
1972         #
1973         #  @ref tui_creation_cylinder "Example"
1974         def MakeCylinder(self,thePnt, theAxis, theR, theH):
1975             """
1976             Create a cylinder with given base point, axis, radius and height.
1977
1978             Parameters:
1979                 thePnt Central point of cylinder base.
1980                 theAxis Cylinder axis.
1981                 theR Cylinder radius.
1982                 theH Cylinder height.
1983
1984             Returns:
1985                 New GEOM.GEOM_Object, containing the created cylinder.
1986             """
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)
1992             return anObj
1993
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.
2000         #
2001         #  @ref tui_creation_cylinder "Example"
2002         def MakeCylinderRH(self,theR, theH):
2003             """
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.
2007
2008             Parameters:
2009                 theR Cylinder radius.
2010                 theH Cylinder height.
2011
2012             Returns:
2013                 New GEOM.GEOM_Object, containing the created cylinder.
2014             """
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)
2020             return anObj
2021
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.
2026         #
2027         #  @ref tui_creation_sphere "Example"
2028         def MakeSpherePntR(self, thePnt, theR):
2029             """
2030             Create a sphere with given center and radius.
2031
2032             Parameters:
2033                 thePnt Sphere center.
2034                 theR Sphere radius.
2035
2036             Returns:
2037                 New GEOM.GEOM_Object, containing the created sphere.
2038             """
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)
2044             return anObj
2045
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.
2050         #
2051         #  @ref tui_creation_sphere "Example"
2052         def MakeSphere(self, x, y, z, theR):
2053             """
2054             Create a sphere with given center and radius.
2055
2056             Parameters:
2057                 x,y,z Coordinates of sphere center.
2058                 theR Sphere radius.
2059
2060             Returns:
2061                 New GEOM.GEOM_Object, containing the created sphere.
2062             """
2063             # Example: see GEOM_TestAll.py
2064             point = self.MakeVertex(x, y, z)
2065             anObj = self.MakeSpherePntR(point, theR)
2066             return anObj
2067
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.
2071         #
2072         #  @ref tui_creation_sphere "Example"
2073         def MakeSphereR(self, theR):
2074             """
2075             Create a sphere with given radius at the origin of coordinate system.
2076
2077             Parameters:
2078                 theR Sphere radius.
2079
2080             Returns:
2081                 New GEOM.GEOM_Object, containing the created sphere.
2082             """
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)
2088             return anObj
2089
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.
2099         #
2100         #  @ref tui_creation_cone "Example"
2101         def MakeCone(self,thePnt, theAxis, theR1, theR2, theH):
2102             """
2103             Create a cone with given base point, axis, height and radiuses.
2104
2105             Parameters:
2106                 thePnt Central point of the first cone base.
2107                 theAxis Cone axis.
2108                 theR1 Radius of the first cone base.
2109                 theR2 Radius of the second cone base.
2110                 theH Cone height.
2111
2112            Note:
2113                 If both radiuses are non-zero, the cone will be truncated.
2114                 If the radiuses are equal, a cylinder will be created instead.
2115
2116            Returns:
2117                 New GEOM.GEOM_Object, containing the created cone.
2118             """
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)
2124             return anObj
2125
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.
2135         #
2136         #  @ref tui_creation_cone "Example"
2137         def MakeConeR1R2H(self,theR1, theR2, theH):
2138             """
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.
2142
2143             Parameters:
2144                 theR1 Radius of the first cone base.
2145                 theR2 Radius of the second cone base.
2146                 theH Cone height.
2147
2148             Note:
2149                 If both radiuses are non-zero, the cone will be truncated.
2150                 If the radiuses are equal, a cylinder will be created instead.
2151
2152            Returns:
2153                 New GEOM.GEOM_Object, containing the created cone.
2154             """
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)
2160             return anObj
2161
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.
2168         #
2169         #  @ref tui_creation_torus "Example"
2170         def MakeTorus(self, thePnt, theVec, theRMajor, theRMinor):
2171             """
2172             Create a torus with given center, normal vector and radiuses.
2173
2174             Parameters:
2175                 thePnt Torus central point.
2176                 theVec Torus axis of symmetry.
2177                 theRMajor Torus major radius.
2178                 theRMinor Torus minor radius.
2179
2180            Returns:
2181                 New GEOM.GEOM_Object, containing the created torus.
2182             """
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)
2188             return anObj
2189
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.
2194         #
2195         #  @ref tui_creation_torus "Example"
2196         def MakeTorusRR(self, theRMajor, theRMinor):
2197             """
2198            Create a torus with given radiuses at the origin of coordinate system.
2199
2200            Parameters:
2201                 theRMajor Torus major radius.
2202                 theRMinor Torus minor radius.
2203
2204            Returns:
2205                 New GEOM.GEOM_Object, containing the created torus.
2206             """
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)
2212             return anObj
2213
2214         # end of l3_3d_primitives
2215         ## @}
2216
2217         ## @addtogroup l3_complex
2218         ## @{
2219
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.
2227         #
2228         #  @ref tui_creation_prism "Example"
2229         def MakePrism(self, theBase, thePoint1, thePoint2, theScaleFactor = -1.0):
2230             """
2231             Create a shape by extrusion of the base shape along a vector, defined by two points.
2232
2233             Parameters:
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.
2239
2240             Returns:
2241                 New GEOM.GEOM_Object, containing the created prism.
2242             """
2243             # Example: see GEOM_TestAll.py
2244             anObj = None
2245             Parameters = ""
2246             if theScaleFactor > 0:
2247                 theScaleFactor,Parameters = ParseParameters(theScaleFactor)
2248                 anObj = self.PrimOp.MakePrismTwoPntWithScaling(theBase, thePoint1, thePoint2, theScaleFactor)
2249             else:
2250                 anObj = self.PrimOp.MakePrismTwoPnt(theBase, thePoint1, thePoint2)
2251             RaiseIfFailed("MakePrismTwoPnt", self.PrimOp)
2252             anObj.SetParameters(Parameters)
2253             return anObj
2254
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.
2261         #
2262         #  @ref tui_creation_prism "Example"
2263         def MakePrism2Ways(self, theBase, thePoint1, thePoint2):
2264             """
2265             Create a shape by extrusion of the base shape along a
2266             vector, defined by two points, in 2 Ways (forward/backward).
2267
2268             Parameters:
2269                 theBase Base shape to be extruded.
2270                 thePoint1 First end of extrusion vector.
2271                 thePoint2 Second end of extrusion vector.
2272
2273             Returns:
2274                 New GEOM.GEOM_Object, containing the created prism.
2275             """
2276             # Example: see GEOM_TestAll.py
2277             anObj = self.PrimOp.MakePrismTwoPnt2Ways(theBase, thePoint1, thePoint2)
2278             RaiseIfFailed("MakePrismTwoPnt", self.PrimOp)
2279             return anObj
2280
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.
2290         #
2291         #  @ref tui_creation_prism "Example"
2292         def MakePrismVecH(self, theBase, theVec, theH, theScaleFactor = -1.0):
2293             """
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.
2297
2298             Parameters:
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.
2304
2305             Returns:
2306                 New GEOM.GEOM_Object, containing the created prism.
2307             """
2308             # Example: see GEOM_TestAll.py
2309             anObj = None
2310             Parameters = ""
2311             if theScaleFactor > 0:
2312                 theH,theScaleFactor,Parameters = ParseParameters(theH,theScaleFactor)
2313                 anObj = self.PrimOp.MakePrismVecHWithScaling(theBase, theVec, theH, theScaleFactor)
2314             else:
2315                 theH,Parameters = ParseParameters(theH)
2316                 anObj = self.PrimOp.MakePrismVecH(theBase, theVec, theH)
2317             RaiseIfFailed("MakePrismVecH", self.PrimOp)
2318             anObj.SetParameters(Parameters)
2319             return anObj
2320
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.
2328         #
2329         #  @ref tui_creation_prism "Example"
2330         def MakePrismVecH2Ways(self, theBase, theVec, theH):
2331             """
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).
2335
2336             Parameters:
2337                 theBase Base shape to be extruded.
2338                 theVec Direction of extrusion.
2339                 theH Prism dimension along theVec in forward direction.
2340
2341             Returns:
2342                 New GEOM.GEOM_Object, containing the created prism.
2343             """
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)
2349             return anObj
2350
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.
2357         #
2358         #  @ref tui_creation_prism "Example"
2359         def MakePrismDXDYDZ(self, theBase, theDX, theDY, theDZ, theScaleFactor = -1.0):
2360             """
2361             Create a shape by extrusion of the base shape along the dx, dy, dz direction
2362
2363             Parameters:
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.
2368
2369             Returns:
2370                 New GEOM.GEOM_Object, containing the created prism.
2371             """
2372             # Example: see GEOM_TestAll.py
2373             anObj = None
2374             Parameters = ""
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)
2378             else:
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)
2383             return anObj
2384
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.
2391         #
2392         #  @ref tui_creation_prism "Example"
2393         def MakePrismDXDYDZ2Ways(self, theBase, theDX, theDY, theDZ):
2394             """
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).
2398
2399             Parameters:
2400                 theBase Base shape to be extruded.
2401                 theDX, theDY, theDZ Directions of extrusion.
2402
2403             Returns:
2404                 New GEOM.GEOM_Object, containing the created prism.
2405             """
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)
2411             return anObj
2412
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.
2420         #
2421         #  @ref tui_creation_revolution "Example"
2422         def MakeRevolution(self, theBase, theAxis, theAngle):
2423             """
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.
2427
2428             Parameters:
2429                 theBase Base shape to be rotated.
2430                 theAxis Rotation axis.
2431                 theAngle Rotation angle in radians.
2432
2433             Returns:
2434                 New GEOM.GEOM_Object, containing the created revolution.
2435             """
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)
2441             return anObj
2442
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.
2451         #
2452         #  @ref tui_creation_revolution "Example"
2453         def MakeRevolution2Ways(self, theBase, theAxis, theAngle):
2454             """
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).
2459
2460             Parameters:
2461                 theBase Base shape to be rotated.
2462                 theAxis Rotation axis.
2463                 theAngle Rotation angle in radians.
2464
2465             Returns:
2466                 New GEOM.GEOM_Object, containing the created revolution.
2467             """
2468             theAngle,Parameters = ParseParameters(theAngle)
2469             anObj = self.PrimOp.MakeRevolutionAxisAngle2Ways(theBase, theAxis, theAngle)
2470             RaiseIfFailed("MakeRevolutionAxisAngle2Ways", self.PrimOp)
2471             anObj.SetParameters(Parameters)
2472             return anObj
2473
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.
2488         #
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):
2492             """
2493             Create a filling from the given compound of contours.
2494
2495             Parameters:
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
2508
2509             Returns:
2510                 New GEOM.GEOM_Object, containing the created filling surface.
2511
2512             Example of usage:
2513                 filling = geompy.MakeFilling(compound, 2, 5, 0.0001, 0.0001, 5)
2514             """
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)
2522             return anObj
2523
2524
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.
2532         #
2533         #  @ref tui_creation_filling "Example"
2534         def MakeFillingNew(self, theShape, theMinDeg=2, theMaxDeg=5, theTol3D=0.0001):
2535             """
2536             Create a filling from the given compound of contours.
2537             This method corresponds to MakeFilling with isApprox=True
2538
2539             Parameters:
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
2544
2545             Returns:
2546                 New GEOM.GEOM_Object, containing the created filling surface.
2547
2548             Example of usage:
2549                 filling = geompy.MakeFillingNew(compound, 2, 5, 0.0001)
2550             """
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)
2557             return anObj
2558
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.
2565         #
2566         #  @ref swig_todo "Example"
2567         def MakeThruSections(self,theSeqSections,theModeSolid,thePreci,theRuled):
2568             """
2569             Create a shell or solid passing through set of sections.Sections should be wires,edges or vertices.
2570
2571             Parameters:
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).
2576
2577             Returns:
2578                 New GEOM.GEOM_Object, containing the created shell or solid.
2579             """
2580             # Example: see GEOM_TestAll.py
2581             anObj = self.PrimOp.MakeThruSections(theSeqSections,theModeSolid,thePreci,theRuled)
2582             RaiseIfFailed("MakeThruSections", self.PrimOp)
2583             return anObj
2584
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.
2590         #
2591         #  @ref tui_creation_pipe "Example"
2592         def MakePipe(self,theBase, thePath):
2593             """
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.
2596
2597             Parameters:
2598                 theBase Base shape to be extruded.
2599                 thePath Path shape to extrude the base shape along it.
2600
2601             Returns:
2602                 New GEOM.GEOM_Object, containing the created pipe.
2603             """
2604             # Example: see GEOM_TestAll.py
2605             anObj = self.PrimOp.MakePipe(theBase, thePath)
2606             RaiseIfFailed("MakePipe", self.PrimOp)
2607             return anObj
2608
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.
2622         #
2623         #  @ref tui_creation_pipe_with_diff_sec "Example"
2624         def MakePipeWithDifferentSections(self, theSeqBases,
2625                                           theLocations, thePath,
2626                                           theWithContact, theWithCorrection):
2627             """
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.
2631
2632             Parameters:
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)
2642
2643             Returns:
2644                 New GEOM.GEOM_Object, containing the created pipe.
2645             """
2646             anObj = self.PrimOp.MakePipeWithDifferentSections(theSeqBases,
2647                                                               theLocations, thePath,
2648                                                               theWithContact, theWithCorrection)
2649             RaiseIfFailed("MakePipeWithDifferentSections", self.PrimOp)
2650             return anObj
2651
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.
2674         #
2675         #  @ref tui_creation_pipe_with_shell_sec "Example"
2676         def MakePipeWithShellSections(self,theSeqBases, theSeqSubBases,
2677                                       theLocations, thePath,
2678                                       theWithContact, theWithCorrection):
2679             """
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.
2683
2684             Parameters:
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)
2703
2704             Returns:
2705                 New GEOM.GEOM_Object, containing the created solids.
2706             """
2707             anObj = self.PrimOp.MakePipeWithShellSections(theSeqBases, theSeqSubBases,
2708                                                           theLocations, thePath,
2709                                                           theWithContact, theWithCorrection)
2710             RaiseIfFailed("MakePipeWithShellSections", self.PrimOp)
2711             return anObj
2712
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):
2721             """
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.
2728             """
2729             res = []
2730             nbsect = len(theSeqBases)
2731             nbsubsect = len(theSeqSubBases)
2732             #print "nbsect = ",nbsect
2733             for i in range(1,nbsect):
2734                 #print "  i = ",i
2735                 tmpSeqBases = [ theSeqBases[i-1], theSeqBases[i] ]
2736                 tmpLocations = [ theLocations[i-1], theLocations[i] ]
2737                 tmpSeqSubBases = []
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)
2745                     break
2746                 else:
2747                     print "Pipe between ",i," and ",i+1," sections is OK"
2748                     res.append(anObj)
2749                     pass
2750                 pass
2751
2752             resc = self.MakeCompound(res)
2753             #resc = self.MakeSewing(res, 0.001)
2754             #print "resc: ",resc
2755             return resc
2756
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.
2761         #
2762         #  @ref tui_creation_pipe_without_path "Example"
2763         def MakePipeShellsWithoutPath(self, theSeqBases, theLocations):
2764             """
2765             Create solids between given sections
2766
2767             Parameters:
2768                 theSeqBases - list of sections (shell or face).
2769                 theLocations - list of corresponding vertexes
2770
2771             Returns:
2772                 New GEOM.GEOM_Object, containing the created solids.
2773             """
2774             anObj = self.PrimOp.MakePipeShellsWithoutPath(theSeqBases, theLocations)
2775             RaiseIfFailed("MakePipeShellsWithoutPath", self.PrimOp)
2776             return anObj
2777
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.
2787         #
2788         #  @ref tui_creation_pipe "Example"
2789         def MakePipeBiNormalAlongVector(self,theBase, thePath, theVec):
2790             """
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.
2794
2795             Parameters:
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.
2801
2802             Returns:
2803                 New GEOM.GEOM_Object, containing the created pipe.
2804             """
2805             # Example: see GEOM_TestAll.py
2806             anObj = self.PrimOp.MakePipeBiNormalAlongVector(theBase, thePath, theVec)
2807             RaiseIfFailed("MakePipeBiNormalAlongVector", self.PrimOp)
2808             return anObj
2809
2810         # end of l3_complex
2811         ## @}
2812
2813         ## @addtogroup l3_advanced
2814         ## @{
2815
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.
2820         #
2821         #  @ref tui_creation_edge "Example"
2822         def MakeEdge(self,thePnt1, thePnt2):
2823             """
2824             Create a linear edge with specified ends.
2825
2826             Parameters:
2827                 thePnt1 Point for the first end of edge.
2828                 thePnt2 Point for the second end of edge.
2829
2830             Returns:
2831                 New GEOM.GEOM_Object, containing the created edge.
2832             """
2833             # Example: see GEOM_TestAll.py
2834             anObj = self.ShapesOp.MakeEdge(thePnt1, thePnt2)
2835             RaiseIfFailed("MakeEdge", self.ShapesOp)
2836             return anObj
2837
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.
2845         #
2846         #  @ref tui_creation_edge "Example"
2847         def MakeEdgeOnCurveByLength(self, theRefCurve, theLength, theStartPoint = None):
2848             """
2849             Create a new edge, corresponding to the given length on the given curve.
2850
2851             Parameters:
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.
2857
2858             Returns:
2859                 New GEOM.GEOM_Object, containing the created edge.
2860             """
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)
2866             return anObj
2867
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.
2873         #
2874         #  @ref tui_creation_edge "Example"
2875         def MakeEdgeWire(self, theWire, theLinearTolerance = 1e-07, theAngularTolerance = 1e-12):
2876             """
2877             Create an edge from specified wire.
2878
2879             Parameters:
2880                 theWire source Wire
2881                 theLinearTolerance linear tolerance value (default = 1e-07)
2882                 theAngularTolerance angular tolerance value (default = 1e-12)
2883
2884             Returns:
2885                 New GEOM.GEOM_Object, containing the created edge.
2886             """
2887             # Example: see GEOM_TestAll.py
2888             anObj = self.ShapesOp.MakeEdgeWire(theWire, theLinearTolerance, theAngularTolerance)
2889             RaiseIfFailed("MakeEdgeWire", self.ShapesOp)
2890             return anObj
2891
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.
2897         #
2898         #  @ref tui_creation_wire "Example"
2899         def MakeWire(self, theEdgesAndWires, theTolerance = 1e-07):
2900             """
2901             Create a wire from the set of edges and wires.
2902
2903             Parameters:
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()).
2907
2908             Returns:
2909                 New GEOM.GEOM_Object, containing the created wire.
2910             """
2911             # Example: see GEOM_TestAll.py
2912             anObj = self.ShapesOp.MakeWire(theEdgesAndWires, theTolerance)
2913             RaiseIfFailed("MakeWire", self.ShapesOp)
2914             return anObj
2915
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.
2924         #
2925         #  @ref tui_creation_face "Example"
2926         def MakeFace(self, theWire, isPlanarWanted):
2927             """
2928             Create a face on the given wire.
2929
2930             Parameters:
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.
2937
2938             Returns:
2939                 New GEOM.GEOM_Object, containing the created face.
2940             """
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."
2945             else:
2946                 RaiseIfFailed("MakeFace", self.ShapesOp)
2947             return anObj
2948
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.
2957         #
2958         #  @ref tui_creation_face "Example"
2959         def MakeFaceWires(self, theWires, isPlanarWanted):
2960             """
2961             Create a face on the given wires set.
2962
2963             Parameters:
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.
2970
2971             Returns:
2972                 New GEOM.GEOM_Object, containing the created face.
2973             """
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."
2978             else:
2979                 RaiseIfFailed("MakeFaceWires", self.ShapesOp)
2980             return anObj
2981
2982         ## See MakeFaceWires() method for details.
2983         #
2984         #  @ref tui_creation_face "Example 1"
2985         #  \n @ref swig_MakeFaces  "Example 2"
2986         def MakeFaces(self, theWires, isPlanarWanted):
2987             """
2988             See geompy.MakeFaceWires() method for details.
2989             """
2990             # Example: see GEOM_TestOthers.py
2991             anObj = self.MakeFaceWires(theWires, isPlanarWanted)
2992             return anObj
2993
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.
2997         #
2998         #  @ref tui_creation_shell "Example"
2999         def MakeShell(self,theFacesAndShells):
3000             """
3001             Create a shell from the set of faces and shells.
3002
3003             Parameters:
3004                 theFacesAndShells List of faces and/or shells.
3005
3006             Returns:
3007                 New GEOM.GEOM_Object, containing the created shell.
3008             """
3009             # Example: see GEOM_TestAll.py
3010             anObj = self.ShapesOp.MakeShell(theFacesAndShells)
3011             RaiseIfFailed("MakeShell", self.ShapesOp)
3012             return anObj
3013
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.
3017         #
3018         #  @ref tui_creation_solid "Example"
3019         def MakeSolid(self,theShells):
3020             """
3021             Create a solid, bounded by the given shells.
3022
3023             Parameters:
3024                 theShells Sequence of bounding shells.
3025
3026             Returns:
3027                 New GEOM.GEOM_Object, containing the created solid.
3028             """
3029             # Example: see GEOM_TestAll.py
3030             anObj = self.ShapesOp.MakeSolidShells(theShells)
3031             RaiseIfFailed("MakeSolidShells", self.ShapesOp)
3032             return anObj
3033
3034         ## Create a compound of the given shapes.
3035         #  @param theShapes List of shapes to put in compound.
3036         #  @return New GEOM.GEOM_Object, containing the created compound.
3037         #
3038         #  @ref tui_creation_compound "Example"
3039         def MakeCompound(self,theShapes):
3040             """
3041             Create a compound of the given shapes.
3042
3043             Parameters:
3044                 theShapes List of shapes to put in compound.
3045
3046             Returns:
3047                 New GEOM.GEOM_Object, containing the created compound.
3048             """
3049             # Example: see GEOM_TestAll.py
3050             anObj = self.ShapesOp.MakeCompound(theShapes)
3051             RaiseIfFailed("MakeCompound", self.ShapesOp)
3052             return anObj
3053
3054         # end of l3_advanced
3055         ## @}
3056
3057         ## @addtogroup l2_measure
3058         ## @{
3059
3060         ## Gives quantity of faces in the given shape.
3061         #  @param theShape Shape to count faces of.
3062         #  @return Quantity of faces.
3063         #
3064         #  @ref swig_NumberOf "Example"
3065         def NumberOfFaces(self, theShape):
3066             """
3067             Gives quantity of faces in the given shape.
3068
3069             Parameters:
3070                 theShape Shape to count faces of.
3071
3072             Returns:
3073                 Quantity of faces.
3074             """
3075             # Example: see GEOM_TestOthers.py
3076             nb_faces = self.ShapesOp.NumberOfFaces(theShape)
3077             RaiseIfFailed("NumberOfFaces", self.ShapesOp)
3078             return nb_faces
3079
3080         ## Gives quantity of edges in the given shape.
3081         #  @param theShape Shape to count edges of.
3082         #  @return Quantity of edges.
3083         #
3084         #  @ref swig_NumberOf "Example"
3085         def NumberOfEdges(self, theShape):
3086             """
3087             Gives quantity of edges in the given shape.
3088
3089             Parameters:
3090                 theShape Shape to count edges of.
3091
3092             Returns:
3093                 Quantity of edges.
3094             """
3095             # Example: see GEOM_TestOthers.py
3096             nb_edges = self.ShapesOp.NumberOfEdges(theShape)
3097             RaiseIfFailed("NumberOfEdges", self.ShapesOp)
3098             return nb_edges
3099
3100         ## Gives quantity of sub-shapes of type theShapeType in the given shape.
3101         #  @param theShape Shape to count sub-shapes of.
3102         #  @param theShapeType Type of sub-shapes to count (see ShapeType())
3103         #  @return Quantity of sub-shapes of given type.
3104         #
3105         #  @ref swig_NumberOf "Example"
3106         def NumberOfSubShapes(self, theShape, theShapeType):
3107             """
3108             Gives quantity of sub-shapes of type theShapeType in the given shape.
3109
3110             Parameters:
3111                 theShape Shape to count sub-shapes of.
3112                 theShapeType Type of sub-shapes to count (see geompy.ShapeType)
3113
3114             Returns:
3115                 Quantity of sub-shapes of given type.
3116             """
3117             # Example: see GEOM_TestOthers.py
3118             nb_ss = self.ShapesOp.NumberOfSubShapes(theShape, theShapeType)
3119             RaiseIfFailed("NumberOfSubShapes", self.ShapesOp)
3120             return nb_ss
3121
3122         ## Gives quantity of solids in the given shape.
3123         #  @param theShape Shape to count solids in.
3124         #  @return Quantity of solids.
3125         #
3126         #  @ref swig_NumberOf "Example"
3127         def NumberOfSolids(self, theShape):
3128             """
3129             Gives quantity of solids in the given shape.
3130
3131             Parameters:
3132                 theShape Shape to count solids in.
3133
3134             Returns:
3135                 Quantity of solids.
3136             """
3137             # Example: see GEOM_TestOthers.py
3138             nb_solids = self.ShapesOp.NumberOfSubShapes(theShape, ShapeType["SOLID"])
3139             RaiseIfFailed("NumberOfSolids", self.ShapesOp)
3140             return nb_solids
3141
3142         # end of l2_measure
3143         ## @}
3144
3145         ## @addtogroup l3_healing
3146         ## @{
3147
3148         ## Reverses an orientation the given shape.
3149         #  @param theShape Shape to be reversed.
3150         #  @return The reversed copy of theShape.
3151         #
3152         #  @ref swig_ChangeOrientation "Example"
3153         def ChangeOrientation(self,theShape):
3154             """
3155             Reverses an orientation the given shape.
3156
3157             Parameters:
3158                 theShape Shape to be reversed.
3159
3160             Returns:
3161                 The reversed copy of theShape.
3162             """
3163             # Example: see GEOM_TestAll.py
3164             anObj = self.ShapesOp.ChangeOrientation(theShape)
3165             RaiseIfFailed("ChangeOrientation", self.ShapesOp)
3166             return anObj
3167
3168         ## See ChangeOrientation() method for details.
3169         #
3170         #  @ref swig_OrientationChange "Example"
3171         def OrientationChange(self,theShape):
3172             """
3173             See geompy.ChangeOrientation method for details.
3174             """
3175             # Example: see GEOM_TestOthers.py
3176             anObj = self.ChangeOrientation(theShape)
3177             return anObj
3178
3179         # end of l3_healing
3180         ## @}
3181
3182         ## @addtogroup l4_obtain
3183         ## @{
3184
3185         ## Retrieve all free faces from the given shape.
3186         #  Free face is a face, which is not shared between two shells of the shape.
3187         #  @param theShape Shape to find free faces in.
3188         #  @return List of IDs of all free faces, contained in theShape.
3189         #
3190         #  @ref tui_measurement_tools_page "Example"
3191         def GetFreeFacesIDs(self,theShape):
3192             """
3193             Retrieve all free faces from the given shape.
3194             Free face is a face, which is not shared between two shells of the shape.
3195
3196             Parameters:
3197                 theShape Shape to find free faces in.
3198
3199             Returns:
3200                 List of IDs of all free faces, contained in theShape.
3201             """
3202             # Example: see GEOM_TestOthers.py
3203             anIDs = self.ShapesOp.GetFreeFacesIDs(theShape)
3204             RaiseIfFailed("GetFreeFacesIDs", self.ShapesOp)
3205             return anIDs
3206
3207         ## Get all sub-shapes of theShape1 of the given type, shared with theShape2.
3208         #  @param theShape1 Shape to find sub-shapes in.
3209         #  @param theShape2 Shape to find shared sub-shapes with.
3210         #  @param theShapeType Type of sub-shapes to be retrieved.
3211         #  @return List of sub-shapes of theShape1, shared with theShape2.
3212         #
3213         #  @ref swig_GetSharedShapes "Example"
3214         def GetSharedShapes(self,theShape1, theShape2, theShapeType):
3215             """
3216             Get all sub-shapes of theShape1 of the given type, shared with theShape2.
3217
3218             Parameters:
3219                 theShape1 Shape to find sub-shapes in.
3220                 theShape2 Shape to find shared sub-shapes with.
3221                 theShapeType Type of sub-shapes to be retrieved.
3222
3223             Returns:
3224                 List of sub-shapes of theShape1, shared with theShape2.
3225             """
3226             # Example: see GEOM_TestOthers.py
3227             aList = self.ShapesOp.GetSharedShapes(theShape1, theShape2, theShapeType)
3228             RaiseIfFailed("GetSharedShapes", self.ShapesOp)
3229             return aList
3230
3231         ## Get all sub-shapes, shared by all shapes in the list <VAR>theShapes</VAR>.
3232         #  @param theShapes Shapes to find common sub-shapes of.
3233         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3234         #  @return List of objects, that are sub-shapes of all given shapes.
3235         #
3236         #  @ref swig_GetSharedShapes "Example"
3237         def GetSharedShapesMulti(self, theShapes, theShapeType):
3238             """
3239             Get all sub-shapes, shared by all shapes in the list theShapes.
3240
3241             Parameters:
3242                 theShapes Shapes to find common sub-shapes of.
3243                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3244
3245             Returns:
3246                 List of GEOM.GEOM_Object, that are sub-shapes of all given shapes.
3247             """
3248             # Example: see GEOM_TestOthers.py
3249             aList = self.ShapesOp.GetSharedShapesMulti(theShapes, theShapeType)
3250             RaiseIfFailed("GetSharedShapesMulti", self.ShapesOp)
3251             return aList
3252
3253         ## Find in <VAR>theShape</VAR> all sub-shapes of type <VAR>theShapeType</VAR>,
3254         #  situated relatively the specified plane by the certain way,
3255         #  defined through <VAR>theState</VAR> parameter.
3256         #  @param theShape Shape to find sub-shapes of.
3257         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3258         #  @param theAx1 Vector (or line, or linear edge), specifying normal
3259         #                direction and location of the plane to find shapes on.
3260         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3261         #  @return List of all found sub-shapes.
3262         #
3263         #  @ref swig_GetShapesOnPlane "Example"
3264         def GetShapesOnPlane(self,theShape, theShapeType, theAx1, theState):
3265             """
3266             Find in theShape all sub-shapes of type theShapeType,
3267             situated relatively the specified plane by the certain way,
3268             defined through theState parameter.
3269
3270             Parameters:
3271                 theShape Shape to find sub-shapes of.
3272                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3273                 theAx1 Vector (or line, or linear edge), specifying normal
3274                        direction and location of the plane to find shapes on.
3275                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3276
3277             Returns:
3278                 List of all found sub-shapes.
3279             """
3280             # Example: see GEOM_TestOthers.py
3281             aList = self.ShapesOp.GetShapesOnPlane(theShape, theShapeType, theAx1, theState)
3282             RaiseIfFailed("GetShapesOnPlane", self.ShapesOp)
3283             return aList
3284
3285         ## Find in <VAR>theShape</VAR> all sub-shapes of type <VAR>theShapeType</VAR>,
3286         #  situated relatively the specified plane by the certain way,
3287         #  defined through <VAR>theState</VAR> parameter.
3288         #  @param theShape Shape to find sub-shapes of.
3289         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3290         #  @param theAx1 Vector (or line, or linear edge), specifying normal
3291         #                direction and location of the plane to find shapes on.
3292         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3293         #  @return List of all found sub-shapes indices.
3294         #
3295         #  @ref swig_GetShapesOnPlaneIDs "Example"
3296         def GetShapesOnPlaneIDs(self,theShape, theShapeType, theAx1, theState):
3297             """
3298             Find in theShape all sub-shapes of type theShapeType,
3299             situated relatively the specified plane by the certain way,
3300             defined through theState parameter.
3301
3302             Parameters:
3303                 theShape Shape to find sub-shapes of.
3304                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3305                 theAx1 Vector (or line, or linear edge), specifying normal
3306                        direction and location of the plane to find shapes on.
3307                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3308
3309             Returns:
3310                 List of all found sub-shapes indices.
3311             """
3312             # Example: see GEOM_TestOthers.py
3313             aList = self.ShapesOp.GetShapesOnPlaneIDs(theShape, theShapeType, theAx1, theState)
3314             RaiseIfFailed("GetShapesOnPlaneIDs", self.ShapesOp)
3315             return aList
3316
3317         ## Find in <VAR>theShape</VAR> all sub-shapes of type <VAR>theShapeType</VAR>,
3318         #  situated relatively the specified plane by the certain way,
3319         #  defined through <VAR>theState</VAR> parameter.
3320         #  @param theShape Shape to find sub-shapes of.
3321         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3322         #  @param theAx1 Vector (or line, or linear edge), specifying normal
3323         #                direction of the plane to find shapes on.
3324         #  @param thePnt Point specifying location of the plane to find shapes on.
3325         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3326         #  @return List of all found sub-shapes.
3327         #
3328         #  @ref swig_GetShapesOnPlaneWithLocation "Example"
3329         def GetShapesOnPlaneWithLocation(self, theShape, theShapeType, theAx1, thePnt, theState):
3330             """
3331             Find in theShape all sub-shapes of type theShapeType,
3332             situated relatively the specified plane by the certain way,
3333             defined through theState parameter.
3334
3335             Parameters:
3336                 theShape Shape to find sub-shapes of.
3337                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3338                 theAx1 Vector (or line, or linear edge), specifying normal
3339                        direction and location of the plane to find shapes on.
3340                 thePnt Point specifying location of the plane to find shapes on.
3341                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3342
3343             Returns:
3344                 List of all found sub-shapes.
3345             """
3346             # Example: see GEOM_TestOthers.py
3347             aList = self.ShapesOp.GetShapesOnPlaneWithLocation(theShape, theShapeType,
3348                                                                theAx1, thePnt, theState)
3349             RaiseIfFailed("GetShapesOnPlaneWithLocation", self.ShapesOp)
3350             return aList
3351
3352         ## Find in <VAR>theShape</VAR> all sub-shapes of type <VAR>theShapeType</VAR>,
3353         #  situated relatively the specified plane by the certain way,
3354         #  defined through <VAR>theState</VAR> parameter.
3355         #  @param theShape Shape to find sub-shapes of.
3356         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3357         #  @param theAx1 Vector (or line, or linear edge), specifying normal
3358         #                direction of the plane to find shapes on.
3359         #  @param thePnt Point specifying location of the plane to find shapes on.
3360         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3361         #  @return List of all found sub-shapes indices.
3362         #
3363         #  @ref swig_GetShapesOnPlaneWithLocationIDs "Example"
3364         def GetShapesOnPlaneWithLocationIDs(self, theShape, theShapeType, theAx1, thePnt, theState):
3365             """
3366             Find in theShape all sub-shapes of type theShapeType,
3367             situated relatively the specified plane by the certain way,
3368             defined through theState parameter.
3369
3370             Parameters:
3371                 theShape Shape to find sub-shapes of.
3372                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3373                 theAx1 Vector (or line, or linear edge), specifying normal
3374                        direction and location of the plane to find shapes on.
3375                 thePnt Point specifying location of the plane to find shapes on.
3376                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3377
3378             Returns:
3379                 List of all found sub-shapes indices.
3380             """
3381             # Example: see GEOM_TestOthers.py
3382             aList = self.ShapesOp.GetShapesOnPlaneWithLocationIDs(theShape, theShapeType,
3383                                                                   theAx1, thePnt, theState)
3384             RaiseIfFailed("GetShapesOnPlaneWithLocationIDs", self.ShapesOp)
3385             return aList
3386
3387         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3388         #  the specified cylinder by the certain way, defined through \a theState parameter.
3389         #  @param theShape Shape to find sub-shapes of.
3390         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3391         #  @param theAxis Vector (or line, or linear edge), specifying
3392         #                 axis of the cylinder to find shapes on.
3393         #  @param theRadius Radius of the cylinder to find shapes on.
3394         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3395         #  @return List of all found sub-shapes.
3396         #
3397         #  @ref swig_GetShapesOnCylinder "Example"
3398         def GetShapesOnCylinder(self, theShape, theShapeType, theAxis, theRadius, theState):
3399             """
3400             Find in theShape all sub-shapes of type theShapeType, situated relatively
3401             the specified cylinder by the certain way, defined through theState parameter.
3402
3403             Parameters:
3404                 theShape Shape to find sub-shapes of.
3405                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3406                 theAxis Vector (or line, or linear edge), specifying
3407                         axis of the cylinder to find shapes on.
3408                 theRadius Radius of the cylinder to find shapes on.
3409                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3410
3411             Returns:
3412                 List of all found sub-shapes.
3413             """
3414             # Example: see GEOM_TestOthers.py
3415             aList = self.ShapesOp.GetShapesOnCylinder(theShape, theShapeType, theAxis, theRadius, theState)
3416             RaiseIfFailed("GetShapesOnCylinder", self.ShapesOp)
3417             return aList
3418
3419         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3420         #  the specified cylinder by the certain way, defined through \a theState parameter.
3421         #  @param theShape Shape to find sub-shapes of.
3422         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3423         #  @param theAxis Vector (or line, or linear edge), specifying
3424         #                 axis of the cylinder to find shapes on.
3425         #  @param theRadius Radius of the cylinder to find shapes on.
3426         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3427         #  @return List of all found sub-shapes indices.
3428         #
3429         #  @ref swig_GetShapesOnCylinderIDs "Example"
3430         def GetShapesOnCylinderIDs(self, theShape, theShapeType, theAxis, theRadius, theState):
3431             """
3432             Find in theShape all sub-shapes of type theShapeType, situated relatively
3433             the specified cylinder by the certain way, defined through theState parameter.
3434
3435             Parameters:
3436                 theShape Shape to find sub-shapes of.
3437                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3438                 theAxis Vector (or line, or linear edge), specifying
3439                         axis of the cylinder to find shapes on.
3440                 theRadius Radius of the cylinder to find shapes on.
3441                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3442
3443             Returns:
3444                 List of all found sub-shapes indices.
3445             """
3446             # Example: see GEOM_TestOthers.py
3447             aList = self.ShapesOp.GetShapesOnCylinderIDs(theShape, theShapeType, theAxis, theRadius, theState)
3448             RaiseIfFailed("GetShapesOnCylinderIDs", self.ShapesOp)
3449             return aList
3450
3451         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3452         #  the specified cylinder by the certain way, defined through \a theState parameter.
3453         #  @param theShape Shape to find sub-shapes of.
3454         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3455         #  @param theAxis Vector (or line, or linear edge), specifying
3456         #                 axis of the cylinder to find shapes on.
3457         #  @param thePnt Point specifying location of the bottom of the cylinder.
3458         #  @param theRadius Radius of the cylinder to find shapes on.
3459         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3460         #  @return List of all found sub-shapes.
3461         #
3462         #  @ref swig_GetShapesOnCylinderWithLocation "Example"
3463         def GetShapesOnCylinderWithLocation(self, theShape, theShapeType, theAxis, thePnt, theRadius, theState):
3464             """
3465             Find in theShape all sub-shapes of type theShapeType, situated relatively
3466             the specified cylinder by the certain way, defined through theState parameter.
3467
3468             Parameters:
3469                 theShape Shape to find sub-shapes of.
3470                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3471                 theAxis Vector (or line, or linear edge), specifying
3472                         axis of the cylinder to find shapes on.
3473                 theRadius Radius of the cylinder to find shapes on.
3474                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3475
3476             Returns:
3477                 List of all found sub-shapes.
3478             """
3479             # Example: see GEOM_TestOthers.py
3480             aList = self.ShapesOp.GetShapesOnCylinderWithLocation(theShape, theShapeType, theAxis, thePnt, theRadius, theState)
3481             RaiseIfFailed("GetShapesOnCylinderWithLocation", self.ShapesOp)
3482             return aList
3483
3484         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3485         #  the specified cylinder by the certain way, defined through \a theState parameter.
3486         #  @param theShape Shape to find sub-shapes of.
3487         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3488         #  @param theAxis Vector (or line, or linear edge), specifying
3489         #                 axis of the cylinder to find shapes on.
3490         #  @param thePnt Point specifying location of the bottom of the cylinder.
3491         #  @param theRadius Radius of the cylinder to find shapes on.
3492         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3493         #  @return List of all found sub-shapes indices
3494         #
3495         #  @ref swig_GetShapesOnCylinderWithLocationIDs "Example"
3496         def GetShapesOnCylinderWithLocationIDs(self, theShape, theShapeType, theAxis, thePnt, theRadius, theState):
3497             """
3498             Find in theShape all sub-shapes of type theShapeType, situated relatively
3499             the specified cylinder by the certain way, defined through theState parameter.
3500
3501             Parameters:
3502                 theShape Shape to find sub-shapes of.
3503                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3504                 theAxis Vector (or line, or linear edge), specifying
3505                         axis of the cylinder to find shapes on.
3506                 theRadius Radius of the cylinder to find shapes on.
3507                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3508
3509             Returns:
3510                 List of all found sub-shapes indices.
3511             """
3512             # Example: see GEOM_TestOthers.py
3513             aList = self.ShapesOp.GetShapesOnCylinderWithLocationIDs(theShape, theShapeType, theAxis, thePnt, theRadius, theState)
3514             RaiseIfFailed("GetShapesOnCylinderWithLocationIDs", self.ShapesOp)
3515             return aList
3516
3517         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3518         #  the specified sphere by the certain way, defined through \a theState parameter.
3519         #  @param theShape Shape to find sub-shapes of.
3520         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3521         #  @param theCenter Point, specifying center of the sphere to find shapes on.
3522         #  @param theRadius Radius of the sphere to find shapes on.
3523         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3524         #  @return List of all found sub-shapes.
3525         #
3526         #  @ref swig_GetShapesOnSphere "Example"
3527         def GetShapesOnSphere(self,theShape, theShapeType, theCenter, theRadius, theState):
3528             """
3529             Find in theShape all sub-shapes of type theShapeType, situated relatively
3530             the specified sphere by the certain way, defined through theState parameter.
3531
3532             Parameters:
3533                 theShape Shape to find sub-shapes of.
3534                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3535                 theCenter Point, specifying center of the sphere to find shapes on.
3536                 theRadius Radius of the sphere to find shapes on.
3537                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3538
3539             Returns:
3540                 List of all found sub-shapes.
3541             """
3542             # Example: see GEOM_TestOthers.py
3543             aList = self.ShapesOp.GetShapesOnSphere(theShape, theShapeType, theCenter, theRadius, theState)
3544             RaiseIfFailed("GetShapesOnSphere", self.ShapesOp)
3545             return aList
3546
3547         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3548         #  the specified sphere by the certain way, defined through \a theState parameter.
3549         #  @param theShape Shape to find sub-shapes of.
3550         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3551         #  @param theCenter Point, specifying center of the sphere to find shapes on.
3552         #  @param theRadius Radius of the sphere to find shapes on.
3553         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3554         #  @return List of all found sub-shapes indices.
3555         #
3556         #  @ref swig_GetShapesOnSphereIDs "Example"
3557         def GetShapesOnSphereIDs(self,theShape, theShapeType, theCenter, theRadius, theState):
3558             """
3559             Find in theShape all sub-shapes of type theShapeType, situated relatively
3560             the specified sphere by the certain way, defined through theState parameter.
3561
3562             Parameters:
3563                 theShape Shape to find sub-shapes of.
3564                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3565                 theCenter Point, specifying center of the sphere to find shapes on.
3566                 theRadius Radius of the sphere to find shapes on.
3567                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3568
3569             Returns:
3570                 List of all found sub-shapes indices.
3571             """
3572             # Example: see GEOM_TestOthers.py
3573             aList = self.ShapesOp.GetShapesOnSphereIDs(theShape, theShapeType, theCenter, theRadius, theState)
3574             RaiseIfFailed("GetShapesOnSphereIDs", self.ShapesOp)
3575             return aList
3576
3577         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3578         #  the specified quadrangle by the certain way, defined through \a theState parameter.
3579         #  @param theShape Shape to find sub-shapes of.
3580         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3581         #  @param theTopLeftPoint Point, specifying top left corner of a quadrangle
3582         #  @param theTopRigthPoint Point, specifying top right corner of a quadrangle
3583         #  @param theBottomLeftPoint Point, specifying bottom left corner of a quadrangle
3584         #  @param theBottomRigthPoint Point, specifying bottom right corner of a quadrangle
3585         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3586         #  @return List of all found sub-shapes.
3587         #
3588         #  @ref swig_GetShapesOnQuadrangle "Example"
3589         def GetShapesOnQuadrangle(self, theShape, theShapeType,
3590                                   theTopLeftPoint, theTopRigthPoint,
3591                                   theBottomLeftPoint, theBottomRigthPoint, theState):
3592             """
3593             Find in theShape all sub-shapes of type theShapeType, situated relatively
3594             the specified quadrangle by the certain way, defined through theState parameter.
3595
3596             Parameters:
3597                 theShape Shape to find sub-shapes of.
3598                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3599                 theTopLeftPoint Point, specifying top left corner of a quadrangle
3600                 theTopRigthPoint Point, specifying top right corner of a quadrangle
3601                 theBottomLeftPoint Point, specifying bottom left corner of a quadrangle
3602                 theBottomRigthPoint Point, specifying bottom right corner of a quadrangle
3603                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3604
3605             Returns:
3606                 List of all found sub-shapes.
3607             """
3608             # Example: see GEOM_TestOthers.py
3609             aList = self.ShapesOp.GetShapesOnQuadrangle(theShape, theShapeType,
3610                                                         theTopLeftPoint, theTopRigthPoint,
3611                                                         theBottomLeftPoint, theBottomRigthPoint, theState)
3612             RaiseIfFailed("GetShapesOnQuadrangle", self.ShapesOp)
3613             return aList
3614
3615         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3616         #  the specified quadrangle by the certain way, defined through \a theState parameter.
3617         #  @param theShape Shape to find sub-shapes of.
3618         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3619         #  @param theTopLeftPoint Point, specifying top left corner of a quadrangle
3620         #  @param theTopRigthPoint Point, specifying top right corner of a quadrangle
3621         #  @param theBottomLeftPoint Point, specifying bottom left corner of a quadrangle
3622         #  @param theBottomRigthPoint Point, specifying bottom right corner of a quadrangle
3623         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3624         #  @return List of all found sub-shapes indices.
3625         #
3626         #  @ref swig_GetShapesOnQuadrangleIDs "Example"
3627         def GetShapesOnQuadrangleIDs(self, theShape, theShapeType,
3628                                      theTopLeftPoint, theTopRigthPoint,
3629                                      theBottomLeftPoint, theBottomRigthPoint, theState):
3630             """
3631             Find in theShape all sub-shapes of type theShapeType, situated relatively
3632             the specified quadrangle by the certain way, defined through theState parameter.
3633
3634             Parameters:
3635                 theShape Shape to find sub-shapes of.
3636                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3637                 theTopLeftPoint Point, specifying top left corner of a quadrangle
3638                 theTopRigthPoint Point, specifying top right corner of a quadrangle
3639                 theBottomLeftPoint Point, specifying bottom left corner of a quadrangle
3640                 theBottomRigthPoint Point, specifying bottom right corner of a quadrangle
3641                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3642
3643             Returns:
3644                 List of all found sub-shapes indices.
3645             """
3646
3647             # Example: see GEOM_TestOthers.py
3648             aList = self.ShapesOp.GetShapesOnQuadrangleIDs(theShape, theShapeType,
3649                                                            theTopLeftPoint, theTopRigthPoint,
3650                                                            theBottomLeftPoint, theBottomRigthPoint, theState)
3651             RaiseIfFailed("GetShapesOnQuadrangleIDs", self.ShapesOp)
3652             return aList
3653
3654         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3655         #  the specified \a theBox by the certain way, defined through \a theState parameter.
3656         #  @param theBox Shape for relative comparing.
3657         #  @param theShape Shape to find sub-shapes of.
3658         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3659         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3660         #  @return List of all found sub-shapes.
3661         #
3662         #  @ref swig_GetShapesOnBox "Example"
3663         def GetShapesOnBox(self, theBox, theShape, theShapeType, theState):
3664             """
3665             Find in theShape all sub-shapes of type theShapeType, situated relatively
3666             the specified theBox by the certain way, defined through theState parameter.
3667
3668             Parameters:
3669                 theBox Shape for relative comparing.
3670                 theShape Shape to find sub-shapes of.
3671                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3672                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3673
3674             Returns:
3675                 List of all found sub-shapes.
3676             """
3677             # Example: see GEOM_TestOthers.py
3678             aList = self.ShapesOp.GetShapesOnBox(theBox, theShape, theShapeType, theState)
3679             RaiseIfFailed("GetShapesOnBox", self.ShapesOp)
3680             return aList
3681
3682         ## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
3683         #  the specified \a theBox by the certain way, defined through \a theState parameter.
3684         #  @param theBox Shape for relative comparing.
3685         #  @param theShape Shape to find sub-shapes of.
3686         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3687         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3688         #  @return List of all found sub-shapes indices.
3689         #
3690         #  @ref swig_GetShapesOnBoxIDs "Example"
3691         def GetShapesOnBoxIDs(self, theBox, theShape, theShapeType, theState):
3692             """
3693             Find in theShape all sub-shapes of type theShapeType, situated relatively
3694             the specified theBox by the certain way, defined through theState parameter.
3695
3696             Parameters:
3697                 theBox Shape for relative comparing.
3698                 theShape Shape to find sub-shapes of.
3699                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3700                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3701
3702             Returns:
3703                 List of all found sub-shapes indices.
3704             """
3705             # Example: see GEOM_TestOthers.py
3706             aList = self.ShapesOp.GetShapesOnBoxIDs(theBox, theShape, theShapeType, theState)
3707             RaiseIfFailed("GetShapesOnBoxIDs", self.ShapesOp)
3708             return aList
3709
3710         ## Find in \a theShape all sub-shapes of type \a theShapeType,
3711         #  situated relatively the specified \a theCheckShape by the
3712         #  certain way, defined through \a theState parameter.
3713         #  @param theCheckShape Shape for relative comparing. It must be a solid.
3714         #  @param theShape Shape to find sub-shapes of.
3715         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3716         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3717         #  @return List of all found sub-shapes.
3718         #
3719         #  @ref swig_GetShapesOnShape "Example"
3720         def GetShapesOnShape(self, theCheckShape, theShape, theShapeType, theState):
3721             """
3722             Find in theShape all sub-shapes of type theShapeType,
3723             situated relatively the specified theCheckShape by the
3724             certain way, defined through theState parameter.
3725
3726             Parameters:
3727                 theCheckShape Shape for relative comparing. It must be a solid.
3728                 theShape Shape to find sub-shapes of.
3729                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3730                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3731
3732             Returns:
3733                 List of all found sub-shapes.
3734             """
3735             # Example: see GEOM_TestOthers.py
3736             aList = self.ShapesOp.GetShapesOnShape(theCheckShape, theShape,
3737                                                    theShapeType, theState)
3738             RaiseIfFailed("GetShapesOnShape", self.ShapesOp)
3739             return aList
3740
3741         ## Find in \a theShape all sub-shapes of type \a theShapeType,
3742         #  situated relatively the specified \a theCheckShape by the
3743         #  certain way, defined through \a theState parameter.
3744         #  @param theCheckShape Shape for relative comparing. It must be a solid.
3745         #  @param theShape Shape to find sub-shapes of.
3746         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3747         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3748         #  @return All found sub-shapes as compound.
3749         #
3750         #  @ref swig_GetShapesOnShapeAsCompound "Example"
3751         def GetShapesOnShapeAsCompound(self, theCheckShape, theShape, theShapeType, theState):
3752             """
3753             Find in theShape all sub-shapes of type theShapeType,
3754             situated relatively the specified theCheckShape by the
3755             certain way, defined through theState parameter.
3756
3757             Parameters:
3758                 theCheckShape Shape for relative comparing. It must be a solid.
3759                 theShape Shape to find sub-shapes of.
3760                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3761                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3762
3763             Returns:
3764                 All found sub-shapes as compound.
3765             """
3766             # Example: see GEOM_TestOthers.py
3767             anObj = self.ShapesOp.GetShapesOnShapeAsCompound(theCheckShape, theShape,
3768                                                              theShapeType, theState)
3769             RaiseIfFailed("GetShapesOnShapeAsCompound", self.ShapesOp)
3770             return anObj
3771
3772         ## Find in \a theShape all sub-shapes of type \a theShapeType,
3773         #  situated relatively the specified \a theCheckShape by the
3774         #  certain way, defined through \a theState parameter.
3775         #  @param theCheckShape Shape for relative comparing. It must be a solid.
3776         #  @param theShape Shape to find sub-shapes of.
3777         #  @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
3778         #  @param theState The state of the sub-shapes to find (see GEOM::shape_state)
3779         #  @return List of all found sub-shapes indices.
3780         #
3781         #  @ref swig_GetShapesOnShapeIDs "Example"
3782         def GetShapesOnShapeIDs(self, theCheckShape, theShape, theShapeType, theState):
3783             """
3784             Find in theShape all sub-shapes of type theShapeType,
3785             situated relatively the specified theCheckShape by the
3786             certain way, defined through theState parameter.
3787
3788             Parameters:
3789                 theCheckShape Shape for relative comparing. It must be a solid.
3790                 theShape Shape to find sub-shapes of.
3791                 theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
3792                 theState The state of the sub-shapes to find (see GEOM::shape_state)
3793
3794             Returns:
3795                 List of all found sub-shapes indices.
3796             """
3797             # Example: see GEOM_TestOthers.py
3798             aList = self.ShapesOp.GetShapesOnShapeIDs(theCheckShape, theShape,
3799                                                       theShapeType, theState)
3800             RaiseIfFailed("GetShapesOnShapeIDs", self.ShapesOp)
3801             return aList
3802
3803         ## Get sub-shape(s) of theShapeWhere, which are
3804         #  coincident with \a theShapeWhat or could be a part of it.
3805         #  @param theShapeWhere Shape to find sub-shapes of.
3806         #  @param theShapeWhat Shape, specifying what to find.
3807         #  @param isNewImplementation implementation of GetInPlace functionality
3808         #             (default = False, old alghorithm based on shape properties)
3809         #  @return Group of all found sub-shapes or a single found sub-shape.
3810         #
3811         #  @note This function has a restriction on argument shapes.
3812         #        If \a theShapeWhere has curved parts with significantly
3813         #        outstanding centres (i.e. the mass centre of a part is closer to
3814         #        \a theShapeWhat than to the part), such parts will not be found.
3815         #        @image html get_in_place_lost_part.png
3816         #
3817         #  @ref swig_GetInPlace "Example"
3818         def GetInPlace(self, theShapeWhere, theShapeWhat, isNewImplementation = False):
3819             """
3820             Get sub-shape(s) of theShapeWhere, which are
3821             coincident with  theShapeWhat or could be a part of it.
3822
3823             Parameters:
3824                 theShapeWhere Shape to find sub-shapes of.
3825                 theShapeWhat Shape, specifying what to find.
3826                 isNewImplementation Implementation of GetInPlace functionality
3827                                     (default = False, old alghorithm based on shape properties)
3828
3829             Returns:
3830                 Group of all found sub-shapes or a single found sub-shape.
3831
3832
3833             Note:
3834                 This function has a restriction on argument shapes.
3835                 If theShapeWhere has curved parts with significantly
3836                 outstanding centres (i.e. the mass centre of a part is closer to
3837                 theShapeWhat than to the part), such parts will not be found.
3838             """
3839             # Example: see GEOM_TestOthers.py
3840             anObj = None
3841             if isNewImplementation:
3842                 anObj = self.ShapesOp.GetInPlace(theShapeWhere, theShapeWhat)
3843             else:
3844                 anObj = self.ShapesOp.GetInPlaceOld(theShapeWhere, theShapeWhat)
3845                 pass
3846             RaiseIfFailed("GetInPlace", self.ShapesOp)
3847             return anObj
3848
3849         ## Get sub-shape(s) of \a theShapeWhere, which are
3850         #  coincident with \a theShapeWhat or could be a part of it.
3851         #
3852         #  Implementation of this method is based on a saved history of an operation,
3853         #  produced \a theShapeWhere. The \a theShapeWhat must be among this operation's
3854         #  arguments (an argument shape or a sub-shape of an argument shape).
3855         #  The operation could be the Partition or one of boolean operations,
3856         #  performed on simple shapes (not on compounds).
3857         #
3858         #  @param theShapeWhere Shape to find sub-shapes of.
3859         #  @param theShapeWhat Shape, specifying what to find (must be in the
3860         #                      building history of the ShapeWhere).
3861         #  @return Group of all found sub-shapes or a single found sub-shape.
3862         #
3863         #  @ref swig_GetInPlace "Example"
3864         def GetInPlaceByHistory(self, theShapeWhere, theShapeWhat):
3865             """
3866             Implementation of this method is based on a saved history of an operation,
3867             produced theShapeWhere. The theShapeWhat must be among this operation's
3868             arguments (an argument shape or a sub-shape of an argument shape).
3869             The operation could be the Partition or one of boolean operations,
3870             performed on simple shapes (not on compounds).
3871
3872             Parameters:
3873                 theShapeWhere Shape to find sub-shapes of.
3874                 theShapeWhat Shape, specifying what to find (must be in the
3875                                 building history of the ShapeWhere).
3876
3877             Returns:
3878                 Group of all found sub-shapes or a single found sub-shape.
3879             """
3880             # Example: see GEOM_TestOthers.py
3881             anObj = self.ShapesOp.GetInPlaceByHistory(theShapeWhere, theShapeWhat)
3882             RaiseIfFailed("GetInPlaceByHistory", self.ShapesOp)
3883             return anObj
3884
3885         ## Get sub-shape of theShapeWhere, which is
3886         #  equal to \a theShapeWhat.
3887         #  @param theShapeWhere Shape to find sub-shape of.
3888         #  @param theShapeWhat Shape, specifying what to find.
3889         #  @return New GEOM.GEOM_Object for found sub-shape.
3890         #
3891         #  @ref swig_GetSame "Example"
3892         def GetSame(self,theShapeWhere, theShapeWhat):
3893             """
3894             Get sub-shape of theShapeWhere, which is
3895             equal to theShapeWhat.
3896
3897             Parameters:
3898                 theShapeWhere Shape to find sub-shape of.
3899                 theShapeWhat Shape, specifying what to find.
3900
3901             Returns:
3902                 New GEOM.GEOM_Object for found sub-shape.
3903             """
3904             anObj = self.ShapesOp.GetSame(theShapeWhere, theShapeWhat)
3905             RaiseIfFailed("GetSame", self.ShapesOp)
3906             return anObj
3907
3908
3909         ## Get sub-shape indices of theShapeWhere, which is
3910         #  equal to \a theShapeWhat.
3911         #  @param theShapeWhere Shape to find sub-shape of.
3912         #  @param theShapeWhat Shape, specifying what to find.
3913         #  @return List of all found sub-shapes indices.
3914         #
3915         #  @ref swig_GetSame "Example"
3916         def GetSameIDs(self,theShapeWhere, theShapeWhat):
3917             """
3918             Get sub-shape indices of theShapeWhere, which is
3919             equal to theShapeWhat.
3920
3921             Parameters:
3922                 theShapeWhere Shape to find sub-shape of.
3923                 theShapeWhat Shape, specifying what to find.
3924
3925             Returns:
3926                 List of all found sub-shapes indices.
3927             """
3928             anObj = self.ShapesOp.GetSameIDs(theShapeWhere, theShapeWhat)
3929             RaiseIfFailed("GetSameIDs", self.ShapesOp)
3930             return anObj
3931
3932
3933         # end of l4_obtain
3934         ## @}
3935
3936         ## @addtogroup l4_access
3937         ## @{
3938
3939         ## Obtain a composite sub-shape of <VAR>aShape</VAR>, composed from sub-shapes
3940         #  of aShape, selected by their unique IDs inside <VAR>aShape</VAR>
3941         #  @param aShape Shape to get sub-shape of.
3942         #  @param ListOfID List of sub-shapes indices.
3943         #  @return Found sub-shape.
3944         #
3945         #  @ref swig_all_decompose "Example"
3946         def GetSubShape(self, aShape, ListOfID):
3947             """
3948             Obtain a composite sub-shape of aShape, composed from sub-shapes
3949             of aShape, selected by their unique IDs inside aShape
3950
3951             Parameters:
3952                aShape Shape to get sub-shape of.
3953                ListOfID List of sub-shapes indices.
3954
3955             Returns:
3956                 Found sub-shape.
3957             """
3958             # Example: see GEOM_TestAll.py
3959             anObj = self.AddSubShape(aShape,ListOfID)
3960             return anObj
3961
3962         ## Obtain unique ID of sub-shape <VAR>aSubShape</VAR> inside <VAR>aShape</VAR>
3963         #  of aShape, selected by their unique IDs inside <VAR>aShape</VAR>
3964         #  @param aShape Shape to get sub-shape of.
3965         #  @param aSubShape Sub-shapes of aShape.
3966         #  @return ID of found sub-shape.
3967         #
3968         #  @ref swig_all_decompose "Example"
3969         def GetSubShapeID(self, aShape, aSubShape):
3970             """
3971             Obtain unique ID of sub-shape aSubShape inside aShape
3972             of aShape, selected by their unique IDs inside aShape
3973
3974             Parameters:
3975                aShape Shape to get sub-shape of.
3976                aSubShape Sub-shapes of aShape.
3977
3978             Returns:
3979                ID of found sub-shape.
3980             """
3981             # Example: see GEOM_TestAll.py
3982             anID = self.LocalOp.GetSubShapeIndex(aShape, aSubShape)
3983             RaiseIfFailed("GetSubShapeIndex", self.LocalOp)
3984             return anID
3985
3986         # end of l4_access
3987         ## @}
3988
3989         ## @addtogroup l4_decompose
3990         ## @{
3991
3992         ## Get all sub-shapes and groups of \a theShape,
3993         #  that were created already by any other methods.
3994         #  @param theShape Any shape.
3995         #  @param theGroupsOnly If this parameter is TRUE, only groups will be
3996         #                       returned, else all found sub-shapes and groups.
3997         #  @return List of existing sub-objects of \a theShape.
3998         #
3999         #  @ref swig_all_decompose "Example"
4000         def GetExistingSubObjects(self, theShape, theGroupsOnly = False):
4001             """
4002             Get all sub-shapes and groups of theShape,
4003             that were created already by any other methods.
4004
4005             Parameters:
4006                 theShape Any shape.
4007                 theGroupsOnly If this parameter is TRUE, only groups will be
4008                                  returned, else all found sub-shapes and groups.
4009
4010             Returns:
4011                 List of existing sub-objects of theShape.
4012             """
4013             # Example: see GEOM_TestAll.py
4014             ListObj = self.ShapesOp.GetExistingSubObjects(theShape, theGroupsOnly)
4015             RaiseIfFailed("GetExistingSubObjects", self.ShapesOp)
4016             return ListObj
4017
4018         ## Get all groups of \a theShape,
4019         #  that were created already by any other methods.
4020         #  @param theShape Any shape.
4021         #  @return List of existing groups of \a theShape.
4022         #
4023         #  @ref swig_all_decompose "Example"
4024         def GetGroups(self, theShape):
4025             """
4026             Get all groups of theShape,
4027             that were created already by any other methods.
4028
4029             Parameters:
4030                 theShape Any shape.
4031
4032             Returns:
4033                 List of existing groups of theShape.
4034             """
4035             # Example: see GEOM_TestAll.py
4036             ListObj = self.ShapesOp.GetExistingSubObjects(theShape, True)
4037             RaiseIfFailed("GetExistingSubObjects", self.ShapesOp)
4038             return ListObj
4039
4040         ## Explode a shape on sub-shapes of a given type.
4041         #  If the shape itself matches the type, it is also returned.
4042         #  @param aShape Shape to be exploded.
4043         #  @param aType Type of sub-shapes to be retrieved (see ShapeType())
4044         #  @return List of sub-shapes of type theShapeType, contained in theShape.
4045         #
4046         #  @ref swig_all_decompose "Example"
4047         def SubShapeAll(self, aShape, aType):
4048             """
4049             Explode a shape on sub-shapes of a given type.
4050             If the shape itself matches the type, it is also returned.
4051
4052             Parameters:
4053                 aShape Shape to be exploded.
4054                 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4055
4056             Returns:
4057                 List of sub-shapes of type theShapeType, contained in theShape.
4058             """
4059             # Example: see GEOM_TestAll.py
4060             ListObj = self.ShapesOp.MakeAllSubShapes(aShape, aType, False)
4061             RaiseIfFailed("SubShapeAll", self.ShapesOp)
4062             return ListObj
4063
4064         ## Explode a shape on sub-shapes of a given type.
4065         #  @param aShape Shape to be exploded.
4066         #  @param aType Type of sub-shapes to be retrieved (see ShapeType())
4067         #  @return List of IDs of sub-shapes.
4068         #
4069         #  @ref swig_all_decompose "Example"
4070         def SubShapeAllIDs(self, aShape, aType):
4071             """
4072             Explode a shape on sub-shapes of a given type.
4073
4074             Parameters:
4075                 aShape Shape to be exploded (see geompy.ShapeType)
4076                 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4077
4078             Returns:
4079                 List of IDs of sub-shapes.
4080             """
4081             ListObj = self.ShapesOp.GetAllSubShapesIDs(aShape, aType, False)
4082             RaiseIfFailed("SubShapeAllIDs", self.ShapesOp)
4083             return ListObj
4084
4085         ## Obtain a compound of sub-shapes of <VAR>aShape</VAR>,
4086         #  selected by they indices in list of all sub-shapes of type <VAR>aType</VAR>.
4087         #  Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
4088         #  @param aShape Shape to get sub-shape of.
4089         #  @param ListOfInd List of sub-shapes indices.
4090         #  @param aType Type of sub-shapes to be retrieved (see ShapeType())
4091         #  @return A compound of sub-shapes of aShape.
4092         #
4093         #  @ref swig_all_decompose "Example"
4094         def SubShape(self, aShape, aType, ListOfInd):
4095             """
4096             Obtain a compound of sub-shapes of aShape,
4097             selected by they indices in list of all sub-shapes of type aType.
4098             Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
4099
4100             Parameters:
4101                 aShape Shape to get sub-shape of.
4102                 ListOfID List of sub-shapes indices.
4103                 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4104
4105             Returns:
4106                 A compound of sub-shapes of aShape.
4107             """
4108             # Example: see GEOM_TestAll.py
4109             ListOfIDs = []
4110             AllShapeIDsList = self.SubShapeAllIDs(aShape, aType)
4111             for ind in ListOfInd:
4112                 ListOfIDs.append(AllShapeIDsList[ind - 1])
4113             anObj = self.GetSubShape(aShape, ListOfIDs)
4114             return anObj
4115
4116         ## Explode a shape on sub-shapes of a given type.
4117         #  Sub-shapes will be sorted by coordinates of their gravity centers.
4118         #  If the shape itself matches the type, it is also returned.
4119         #  @param aShape Shape to be exploded.
4120         #  @param aType Type of sub-shapes to be retrieved (see ShapeType())
4121         #  @return List of sub-shapes of type theShapeType, contained in theShape.
4122         #
4123         #  @ref swig_SubShapeAllSorted "Example"
4124         def SubShapeAllSortedCentres(self, aShape, aType):
4125             """
4126             Explode a shape on sub-shapes of a given type.
4127             Sub-shapes will be sorted by coordinates of their gravity centers.
4128             If the shape itself matches the type, it is also returned.
4129
4130             Parameters:
4131                 aShape Shape to be exploded.
4132                 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4133
4134             Returns:
4135                 List of sub-shapes of type theShapeType, contained in theShape.
4136             """
4137             # Example: see GEOM_TestAll.py
4138             ListObj = self.ShapesOp.MakeAllSubShapes(aShape, aType, True)
4139             RaiseIfFailed("SubShapeAllSortedCentres", self.ShapesOp)
4140             return ListObj
4141
4142         ## Explode a shape on sub-shapes of a given type.
4143         #  Sub-shapes will be sorted by coordinates of their gravity centers.
4144         #  @param aShape Shape to be exploded.
4145         #  @param aType Type of sub-shapes to be retrieved (see ShapeType())
4146         #  @return List of IDs of sub-shapes.
4147         #
4148         #  @ref swig_all_decompose "Example"
4149         def SubShapeAllSortedCentresIDs(self, aShape, aType):
4150             """
4151             Explode a shape on sub-shapes of a given type.
4152             Sub-shapes will be sorted by coordinates of their gravity centers.
4153
4154             Parameters:
4155                 aShape Shape to be exploded.
4156                 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4157
4158             Returns:
4159                 List of IDs of sub-shapes.
4160             """
4161             ListIDs = self.ShapesOp.GetAllSubShapesIDs(aShape, aType, True)
4162             RaiseIfFailed("SubShapeAllIDs", self.ShapesOp)
4163             return ListIDs
4164
4165         ## Obtain a compound of sub-shapes of <VAR>aShape</VAR>,
4166         #  selected by they indices in sorted list of all sub-shapes of type <VAR>aType</VAR>.
4167         #  Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
4168         #  @param aShape Shape to get sub-shape of.
4169         #  @param ListOfInd List of sub-shapes indices.
4170         #  @param aType Type of sub-shapes to be retrieved (see ShapeType())
4171         #  @return A compound of sub-shapes of aShape.
4172         #
4173         #  @ref swig_all_decompose "Example"
4174         def SubShapeSortedCentres(self, aShape, aType, ListOfInd):
4175             """
4176             Obtain a compound of sub-shapes of aShape,
4177             selected by they indices in sorted list of all sub-shapes of type aType.
4178             Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
4179
4180             Parameters:
4181                 aShape Shape to get sub-shape of.
4182                 ListOfID List of sub-shapes indices.
4183                 aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
4184
4185             Returns:
4186                 A compound of sub-shapes of aShape.
4187             """
4188             # Example: see GEOM_TestAll.py
4189             ListOfIDs = []
4190             AllShapeIDsList = self.SubShapeAllSortedCentresIDs(aShape, aType)
4191             for ind in ListOfInd:
4192                 ListOfIDs.append(AllShapeIDsList[ind - 1])
4193             anObj = self.GetSubShape(aShape, ListOfIDs)
4194             return anObj
4195
4196         ## Extract shapes (excluding the main shape) of given type.
4197         #  @param aShape The shape.
4198         #  @param aType  The shape type (see ShapeType())
4199         #  @param isSorted Boolean flag to switch sorting on/off.
4200         #  @return List of sub-shapes of type aType, contained in aShape.
4201         #
4202         #  @ref swig_FilletChamfer "Example"
4203         def ExtractShapes(self, aShape, aType, isSorted = False):
4204             """
4205             Extract shapes (excluding the main shape) of given type.
4206
4207             Parameters:
4208                 aShape The shape.
4209                 aType  The shape type (see geompy.ShapeType)
4210                 isSorted Boolean flag to switch sorting on/off.
4211
4212             Returns:
4213                 List of sub-shapes of type aType, contained in aShape.
4214             """
4215             # Example: see GEOM_TestAll.py
4216             ListObj = self.ShapesOp.ExtractSubShapes(aShape, aType, isSorted)
4217             RaiseIfFailed("ExtractSubShapes", self.ShapesOp)
4218             return ListObj
4219
4220         ## Get a set of sub-shapes defined by their unique IDs inside <VAR>aShape</VAR>
4221         #  @param aShape Main shape.
4222         #  @param anIDs List of unique IDs of sub-shapes inside <VAR>aShape</VAR>.
4223         #  @return List of GEOM.GEOM_Object, corresponding to found sub-shapes.
4224         #
4225         #  @ref swig_all_decompose "Example"
4226         def SubShapes(self, aShape, anIDs):
4227             """
4228             Get a set of sub-shapes defined by their unique IDs inside theMainShape
4229
4230             Parameters:
4231                 aShape Main shape.
4232                 anIDs List of unique IDs of sub-shapes inside theMainShape.
4233
4234             Returns:
4235                 List of GEOM.GEOM_Object, corresponding to found sub-shapes.
4236             """
4237             # Example: see GEOM_TestAll.py
4238             ListObj = self.ShapesOp.MakeSubShapes(aShape, anIDs)
4239             RaiseIfFailed("SubShapes", self.ShapesOp)
4240             return ListObj
4241
4242         # end of l4_decompose
4243         ## @}
4244
4245         ## @addtogroup l4_decompose_d
4246         ## @{
4247
4248         ## Deprecated method
4249         #  It works like SubShapeAllSortedCentres(), but wrongly
4250         #  defines centres of faces, shells and solids.
4251         def SubShapeAllSorted(self, aShape, aType):
4252             """
4253             Deprecated method
4254             It works like geompy.SubShapeAllSortedCentres, but wrongly
4255             defines centres of faces, shells and solids.
4256             """
4257             ListObj = self.ShapesOp.MakeExplode(aShape, aType, True)
4258             RaiseIfFailed("MakeExplode", self.ShapesOp)
4259             return ListObj
4260
4261         ## Deprecated method
4262         #  It works like SubShapeAllSortedCentresIDs(), but wrongly
4263         #  defines centres of faces, shells and solids.
4264         def SubShapeAllSortedIDs(self, aShape, aType):
4265             """
4266             Deprecated method
4267             It works like geompy.SubShapeAllSortedCentresIDs, but wrongly
4268             defines centres of faces, shells and solids.
4269             """
4270             ListIDs = self.ShapesOp.SubShapeAllIDs(aShape, aType, True)
4271             RaiseIfFailed("SubShapeAllIDs", self.ShapesOp)
4272             return ListIDs
4273
4274         ## Deprecated method
4275         #  It works like SubShapeSortedCentres(), but has a bug
4276         #  (wrongly defines centres of faces, shells and solids).
4277         def SubShapeSorted(self, aShape, aType, ListOfInd):
4278             """
4279             Deprecated method
4280             It works like geompy.SubShapeSortedCentres, but has a bug
4281             (wrongly defines centres of faces, shells and solids).
4282             """
4283             ListOfIDs = []
4284             AllShapeIDsList = self.SubShapeAllSortedIDs(aShape, aType)
4285             for ind in ListOfInd:
4286                 ListOfIDs.append(AllShapeIDsList[ind - 1])
4287             anObj = self.GetSubShape(aShape, ListOfIDs)
4288             return anObj
4289
4290         # end of l4_decompose_d
4291         ## @}
4292
4293         ## @addtogroup l3_healing
4294         ## @{
4295
4296         ## Apply a sequence of Shape Healing operators to the given object.
4297         #  @param theShape Shape to be processed.
4298         #  @param theOperators List of names of operators ("FixShape", "SplitClosedFaces", etc.).
4299         #  @param theParameters List of names of parameters
4300         #                    ("FixShape.Tolerance3d", "SplitClosedFaces.NbSplitPoints", etc.).
4301         #  @param theValues List of values of parameters, in the same order
4302         #                    as parameters are listed in <VAR>theParameters</VAR> list.
4303         #
4304         #
4305         #  <b> Operators and Parameters: </b> \n
4306         #
4307         #  * \b FixShape - corrects invalid shapes. \n
4308         #  - \b FixShape.Tolerance3d - work tolerance for detection of the problems and correction of them. \n
4309         #  - \b FixShape.MaxTolerance3d - maximal possible tolerance of the shape after correction. \n
4310         #
4311         #  * \b FixFaceSize - removes small faces, such as spots and strips.\n
4312         #  - \b FixFaceSize.Tolerance - defines minimum possible face size. \n
4313         #  - \b DropSmallEdges - removes edges, which merge with neighbouring edges. \n
4314         #  - \b DropSmallEdges.Tolerance3d - defines minimum possible distance between two parallel edges.\n
4315         #
4316         #  * \b SplitAngle - splits faces based on conical surfaces, surfaces of revolution and cylindrical
4317         #    surfaces in segments using a certain angle. \n
4318         #  - \b SplitAngle.Angle - the central angle of the resulting segments (i.e. we obtain two segments
4319         #    if Angle=180, four if Angle=90, etc). \n
4320         #  - \b SplitAngle.MaxTolerance - maximum possible tolerance among the resulting segments.\n
4321         #
4322         #  * \b SplitClosedFaces - splits closed faces in segments.
4323         #    The number of segments depends on the number of splitting points.\n
4324         #  - \b SplitClosedFaces.NbSplitPoints - the number of splitting points.\n
4325         #
4326         #  * \b SplitContinuity - splits shapes to reduce continuities of curves and surfaces.\n
4327         #  - \b SplitContinuity.Tolerance3d - 3D tolerance for correction of geometry.\n
4328         #  - \b SplitContinuity.SurfaceContinuity - required continuity for surfaces.\n
4329         #  - \b SplitContinuity.CurveContinuity - required continuity for curves.\n
4330         #   This and the previous parameters can take the following values:\n
4331         #   \b Parametric \b Continuity \n
4332         #   \b C0 (Positional Continuity): curves are joined (the end positions of curves or surfaces
4333         #   are coincidental. The curves or surfaces may still meet at an angle, giving rise to a sharp corner or edge).\n
4334         #   \b C1 (Tangential Continuity): first derivatives are equal (the end vectors of curves or surfaces are parallel,
4335         #    ruling out sharp edges).\n
4336         #   \b C2 (Curvature Continuity): first and second derivatives are equal (the end vectors of curves or surfaces
4337         #       are of the same magnitude).\n
4338         #   \b CN N-th derivatives are equal (both the direction and the magnitude of the Nth derivatives of curves
4339         #    or surfaces (d/du C(u)) are the same at junction. \n
4340         #   \b Geometric \b Continuity \n
4341         #   \b G1: first derivatives are proportional at junction.\n
4342         #   The curve tangents thus have the same direction, but not necessarily the same magnitude.
4343         #      i.e., C1'(1) = (a,b,c) and C2'(0) = (k*a, k*b, k*c).\n
4344         #   \b G2: first and second derivatives are proportional at junction.
4345         #   As the names imply, geometric continuity requires the geometry to be continuous, while parametric
4346         #    continuity requires that the underlying parameterization was continuous as well.
4347         #   Parametric continuity of order n implies geometric continuity of order n, but not vice-versa.\n
4348         #
4349         #  * \b BsplineRestriction - converts curves and surfaces to Bsplines and processes them with the following parameters:\n
4350         #  - \b BSplineRestriction.SurfaceMode - approximation of surfaces if restriction is necessary.\n
4351         #  - \b BSplineRestriction.Curve3dMode - conversion of any 3D curve to BSpline and approximation.\n
4352         #  - \b BSplineRestriction.Curve2dMode - conversion of any 2D curve to BSpline and approximation.\n
4353         #  - \b BSplineRestriction.Tolerance3d - defines the possibility of surfaces and 3D curves approximation
4354         #       with the specified parameters.\n
4355         #  - \b BSplineRestriction.Tolerance2d - defines the possibility of surfaces and 2D curves approximation
4356         #       with the specified parameters.\n
4357         #  - \b BSplineRestriction.RequiredDegree - required degree of the resulting BSplines.\n
4358         #  - \b BSplineRestriction.RequiredNbSegments - required maximum number of segments of resultant BSplines.\n
4359         #  - \b BSplineRestriction.Continuity3d - continuity of the resulting surfaces and 3D curves.\n
4360         #  - \b BSplineRestriction.Continuity2d - continuity of the resulting 2D curves.\n
4361         #
4362         #  * \b ToBezier - converts curves and surfaces of any type to Bezier curves and surfaces.\n
4363         #  - \b ToBezier.SurfaceMode - if checked in, allows conversion of surfaces.\n
4364         #  - \b ToBezier.Curve3dMode - if checked in, allows conversion of 3D curves.\n
4365         #  - \b ToBezier.Curve2dMode - if checked in, allows conversion of 2D curves.\n
4366         #  - \b ToBezier.MaxTolerance - defines tolerance for detection and correction of problems.\n
4367         #
4368         #  * \b SameParameter - fixes edges of 2D and 3D curves not having the same parameter.\n
4369         #  - \b SameParameter.Tolerance3d - defines tolerance for fixing of edges.\n
4370         #
4371         #
4372         #  @return New GEOM.GEOM_Object, containing processed shape.
4373         #
4374         #  \n @ref tui_shape_processing "Example"
4375         def ProcessShape(self, theShape, theOperators, theParameters, theValues):
4376             """
4377             Apply a sequence of Shape Healing operators to the given object.
4378
4379             Parameters:
4380                 theShape Shape to be processed.
4381                 theValues List of values of parameters, in the same order
4382                           as parameters are listed in theParameters list.
4383                 theOperators List of names of operators ("FixShape", "SplitClosedFaces", etc.).
4384                 theParameters List of names of parameters
4385                               ("FixShape.Tolerance3d", "SplitClosedFaces.NbSplitPoints", etc.).
4386                  Operators and Parameters:
4387
4388                  * FixShape - corrects invalid shapes.
4389                      * FixShape.Tolerance3d - work tolerance for detection of the problems and correction of them.
4390                      * FixShape.MaxTolerance3d - maximal possible tolerance of the shape after correction.
4391                  * FixFaceSize - removes small faces, such as spots and strips.
4392                      * FixFaceSize.Tolerance - defines minimum possible face size.
4393                      * DropSmallEdges - removes edges, which merge with neighbouring edges.
4394                      * DropSmallEdges.Tolerance3d - defines minimum possible distance between two parallel edges.
4395                  * SplitAngle - splits faces based on conical surfaces, surfaces of revolution and cylindrical surfaces
4396                                 in segments using a certain angle.
4397                      * SplitAngle.Angle - the central angle of the resulting segments (i.e. we obtain two segments
4398                                           if Angle=180, four if Angle=90, etc).
4399                      * SplitAngle.MaxTolerance - maximum possible tolerance among the resulting segments.
4400                  * SplitClosedFaces - splits closed faces in segments. The number of segments depends on the number of
4401                                       splitting points.
4402                      * SplitClosedFaces.NbSplitPoints - the number of splitting points.
4403                  * SplitContinuity - splits shapes to reduce continuities of curves and surfaces.
4404                      * SplitContinuity.Tolerance3d - 3D tolerance for correction of geometry.
4405                      * SplitContinuity.SurfaceContinuity - required continuity for surfaces.
4406                      * SplitContinuity.CurveContinuity - required continuity for curves.
4407                        This and the previous parameters can take the following values:
4408
4409                        Parametric Continuity:
4410                        C0 (Positional Continuity): curves are joined (the end positions of curves or surfaces are
4411                                                    coincidental. The curves or surfaces may still meet at an angle,
4412                                                    giving rise to a sharp corner or edge).
4413                        C1 (Tangential Continuity): first derivatives are equal (the end vectors of curves or surfaces
4414                                                    are parallel, ruling out sharp edges).
4415                        C2 (Curvature Continuity): first and second derivatives are equal (the end vectors of curves
4416                                                   or surfaces are of the same magnitude).
4417                        CN N-th derivatives are equal (both the direction and the magnitude of the Nth derivatives of
4418                           curves or surfaces (d/du C(u)) are the same at junction.
4419
4420                        Geometric Continuity:
4421                        G1: first derivatives are proportional at junction.
4422                            The curve tangents thus have the same direction, but not necessarily the same magnitude.
4423                            i.e., C1'(1) = (a,b,c) and C2'(0) = (k*a, k*b, k*c).
4424                        G2: first and second derivatives are proportional at junction. As the names imply,
4425                            geometric continuity requires the geometry to be continuous, while parametric continuity requires
4426                            that the underlying parameterization was continuous as well. Parametric continuity of order n implies
4427                            geometric continuity of order n, but not vice-versa.
4428                  * BsplineRestriction - converts curves and surfaces to Bsplines and processes them with the following parameters:
4429                      * BSplineRestriction.SurfaceMode - approximation of surfaces if restriction is necessary.
4430                      * BSplineRestriction.Curve3dMode - conversion of any 3D curve to BSpline and approximation.
4431                      * BSplineRestriction.Curve2dMode - conversion of any 2D curve to BSpline and approximation.
4432                      * BSplineRestriction.Tolerance3d - defines the possibility of surfaces and 3D curves approximation with
4433                                                         the specified parameters.
4434                      * BSplineRestriction.Tolerance2d - defines the possibility of surfaces and 2D curves approximation with
4435                                                         the specified parameters.
4436                      * BSplineRestriction.RequiredDegree - required degree of the resulting BSplines.
4437                      * BSplineRestriction.RequiredNbSegments - required maximum number of segments of resultant BSplines.
4438                      * BSplineRestriction.Continuity3d - continuity of the resulting surfaces and 3D curves.
4439                      * BSplineRestriction.Continuity2d - continuity of the resulting 2D curves.
4440                  * ToBezier - converts curves and surfaces of any type to Bezier curves and surfaces.
4441                      * ToBezier.SurfaceMode - if checked in, allows conversion of surfaces.
4442                      * ToBezier.Curve3dMode - if checked in, allows conversion of 3D curves.
4443                      * ToBezier.Curve2dMode - if checked in, allows conversion of 2D curves.
4444                      * ToBezier.MaxTolerance - defines tolerance for detection and correction of problems.
4445                  * SameParameter - fixes edges of 2D and 3D curves not having the same parameter.
4446                      * SameParameter.Tolerance3d - defines tolerance for fixing of edges.
4447
4448             Returns:
4449                 New GEOM.GEOM_Object, containing processed shape.
4450
4451             Note: For more information look through SALOME Geometry User's Guide->
4452                   -> Introduction to Geometry-> Repairing Operations-> Shape Processing
4453             """
4454             # Example: see GEOM_TestHealing.py
4455             theValues,Parameters = ParseList(theValues)
4456             anObj = self.HealOp.ProcessShape(theShape, theOperators, theParameters, theValues)
4457             # To avoid script failure in case of good argument shape
4458             if self.HealOp.GetErrorCode() == "ShHealOper_NotError_msg":
4459                 return theShape
4460             RaiseIfFailed("ProcessShape", self.HealOp)
4461             for string in (theOperators + theParameters):
4462                 Parameters = ":" + Parameters
4463                 pass
4464             anObj.SetParameters(Parameters)
4465             return anObj
4466
4467         ## Remove faces from the given object (shape).
4468         #  @param theObject Shape to be processed.
4469         #  @param theFaces Indices of faces to be removed, if EMPTY then the method
4470         #                  removes ALL faces of the given object.
4471         #  @return New GEOM.GEOM_Object, containing processed shape.
4472         #
4473         #  @ref tui_suppress_faces "Example"
4474         def SuppressFaces(self,theObject, theFaces):
4475             """
4476             Remove faces from the given object (shape).
4477
4478             Parameters:
4479                 theObject Shape to be processed.
4480                 theFaces Indices of faces to be removed, if EMPTY then the method
4481                          removes ALL faces of the given object.
4482
4483             Returns:
4484                 New GEOM.GEOM_Object, containing processed shape.
4485             """
4486             # Example: see GEOM_TestHealing.py
4487             anObj = self.HealOp.SuppressFaces(theObject, theFaces)
4488             RaiseIfFailed("SuppressFaces", self.HealOp)
4489             return anObj
4490
4491         ## Sewing of some shapes into single shape.
4492         #  @param ListShape Shapes to be processed.
4493         #  @param theTolerance Required tolerance value.
4494         #  @return New GEOM.GEOM_Object, containing processed shape.
4495         #
4496         #  @ref tui_sewing "Example"
4497         def MakeSewing(self, ListShape, theTolerance):
4498             """
4499             Sewing of some shapes into single shape.
4500
4501             Parameters:
4502                 ListShape Shapes to be processed.
4503                 theTolerance Required tolerance value.
4504
4505             Returns:
4506                 New GEOM.GEOM_Object, containing processed shape.
4507             """
4508             # Example: see GEOM_TestHealing.py
4509             comp = self.MakeCompound(ListShape)
4510             anObj = self.Sew(comp, theTolerance)
4511             return anObj
4512
4513         ## Sewing of the given object.
4514         #  @param theObject Shape to be processed.
4515         #  @param theTolerance Required tolerance value.
4516         #  @return New GEOM.GEOM_Object, containing processed shape.
4517         def Sew(self, theObject, theTolerance):
4518             """
4519             Sewing of the given object.
4520
4521             Parameters:
4522                 theObject Shape to be processed.
4523                 theTolerance Required tolerance value.
4524
4525             Returns:
4526                 New GEOM.GEOM_Object, containing processed shape.
4527             """
4528             # Example: see MakeSewing() above
4529             theTolerance,Parameters = ParseParameters(theTolerance)
4530             anObj = self.HealOp.Sew(theObject, theTolerance)
4531             RaiseIfFailed("Sew", self.HealOp)
4532             anObj.SetParameters(Parameters)
4533             return anObj
4534
4535         ## Remove internal wires and edges from the given object (face).
4536         #  @param theObject Shape to be processed.
4537         #  @param theWires Indices of wires to be removed, if EMPTY then the method
4538         #                  removes ALL internal wires of the given object.
4539         #  @return New GEOM.GEOM_Object, containing processed shape.
4540         #
4541         #  @ref tui_suppress_internal_wires "Example"
4542         def SuppressInternalWires(self,theObject, theWires):
4543             """
4544             Remove internal wires and edges from the given object (face).
4545
4546             Parameters:
4547                 theObject Shape to be processed.
4548                 theWires Indices of wires to be removed, if EMPTY then the method
4549                          removes ALL internal wires of the given object.
4550
4551             Returns:
4552                 New GEOM.GEOM_Object, containing processed shape.
4553             """
4554             # Example: see GEOM_TestHealing.py
4555             anObj = self.HealOp.RemoveIntWires(theObject, theWires)
4556             RaiseIfFailed("RemoveIntWires", self.HealOp)
4557             return anObj
4558
4559         ## Remove internal closed contours (holes) from the given object.
4560         #  @param theObject Shape to be processed.
4561         #  @param theWires Indices of wires to be removed, if EMPTY then the method
4562         #                  removes ALL internal holes of the given object
4563         #  @return New GEOM.GEOM_Object, containing processed shape.
4564         #
4565         #  @ref tui_suppress_holes "Example"
4566         def SuppressHoles(self,theObject, theWires):
4567             """
4568             Remove internal closed contours (holes) from the given object.
4569
4570             Parameters:
4571                 theObject Shape to be processed.
4572                 theWires Indices of wires to be removed, if EMPTY then the method
4573                          removes ALL internal holes of the given object
4574
4575             Returns:
4576                 New GEOM.GEOM_Object, containing processed shape.
4577             """
4578             # Example: see GEOM_TestHealing.py
4579             anObj = self.HealOp.FillHoles(theObject, theWires)
4580             RaiseIfFailed("FillHoles", self.HealOp)
4581             return anObj
4582
4583         ## Close an open wire.
4584         #  @param theObject Shape to be processed.
4585         #  @param theWires Indexes of edge(s) and wire(s) to be closed within <VAR>theObject</VAR>'s shape,
4586         #                  if [ ], then <VAR>theObject</VAR> itself is a wire.
4587         #  @param isCommonVertex If True  : closure by creation of a common vertex,
4588         #                        If False : closure by creation of an edge between ends.
4589         #  @return New GEOM.GEOM_Object, containing processed shape.
4590         #
4591         #  @ref tui_close_contour "Example"
4592         def CloseContour(self,theObject, theWires, isCommonVertex):
4593             """
4594             Close an open wire.
4595
4596             Parameters:
4597                 theObject Shape to be processed.
4598                 theWires Indexes of edge(s) and wire(s) to be closed within theObject's shape,
4599                          if [ ], then theObject itself is a wire.
4600                 isCommonVertex If True  : closure by creation of a common vertex,
4601                                If False : closure by creation of an edge between ends.
4602
4603             Returns:
4604                 New GEOM.GEOM_Object, containing processed shape.
4605             """
4606             # Example: see GEOM_TestHealing.py
4607             anObj = self.HealOp.CloseContour(theObject, theWires, isCommonVertex)
4608             RaiseIfFailed("CloseContour", self.HealOp)
4609             return anObj
4610
4611         ## Addition of a point to a given edge object.
4612         #  @param theObject Shape to be processed.
4613         #  @param theEdgeIndex Index of edge to be divided within theObject's shape,
4614         #                      if -1, then theObject itself is the edge.
4615         #  @param theValue Value of parameter on edge or length parameter,
4616         #                  depending on \a isByParameter.
4617         #  @param isByParameter If TRUE : \a theValue is treated as a curve parameter [0..1], \n
4618         #                       if FALSE : \a theValue is treated as a length parameter [0..1]
4619         #  @return New GEOM.GEOM_Object, containing processed shape.
4620         #
4621         #  @ref tui_add_point_on_edge "Example"
4622         def DivideEdge(self,theObject, theEdgeIndex, theValue, isByParameter):
4623             """
4624             Addition of a point to a given edge object.
4625
4626             Parameters:
4627                 theObject Shape to be processed.
4628                 theEdgeIndex Index of edge to be divided within theObject's shape,
4629                              if -1, then theObject itself is the edge.
4630                 theValue Value of parameter on edge or length parameter,
4631                          depending on isByParameter.
4632                 isByParameter If TRUE :  theValue is treated as a curve parameter [0..1],
4633                               if FALSE : theValue is treated as a length parameter [0..1]
4634
4635             Returns:
4636                 New GEOM.GEOM_Object, containing processed shape.
4637             """
4638             # Example: see GEOM_TestHealing.py
4639             theEdgeIndex,theValue,isByParameter,Parameters = ParseParameters(theEdgeIndex,theValue,isByParameter)
4640             anObj = self.HealOp.DivideEdge(theObject, theEdgeIndex, theValue, isByParameter)
4641             RaiseIfFailed("DivideEdge", self.HealOp)
4642             anObj.SetParameters(Parameters)
4643             return anObj
4644
4645         ## Suppress the vertices in the wire in case if adjacent edges are C1 continuous.
4646         #  @param theWire Wire to minimize the number of C1 continuous edges in.
4647         #  @param theVertices A list of vertices to suppress. If the list
4648         #                     is empty, all vertices in a wire will be assumed.
4649         #  @return New GEOM.GEOM_Object with modified wire.
4650         #
4651         #  @ref tui_fuse_collinear_edges "Example"
4652         def FuseCollinearEdgesWithinWire(self, theWire, theVertices = []):
4653             """
4654             Suppress the vertices in the wire in case if adjacent edges are C1 continuous.
4655
4656             Parameters:
4657                 theWire Wire to minimize the number of C1 continuous edges in.
4658                 theVertices A list of vertices to suppress. If the list
4659                             is empty, all vertices in a wire will be assumed.
4660
4661             Returns:
4662                 New GEOM.GEOM_Object with modified wire.
4663             """
4664             anObj = self.HealOp.FuseCollinearEdgesWithinWire(theWire, theVertices)
4665             RaiseIfFailed("FuseCollinearEdgesWithinWire", self.HealOp)
4666             return anObj
4667
4668         ## Change orientation of the given object. Updates given shape.
4669         #  @param theObject Shape to be processed.
4670         #  @return Updated <var>theObject</var>
4671         #
4672         #  @ref swig_todo "Example"
4673         def ChangeOrientationShell(self,theObject):
4674             """
4675             Change orientation of the given object. Updates given shape.
4676
4677             Parameters:
4678                 theObject Shape to be processed.
4679
4680             Returns:
4681                 Updated theObject
4682             """
4683             theObject = self.HealOp.ChangeOrientation(theObject)
4684             RaiseIfFailed("ChangeOrientation", self.HealOp)
4685             pass
4686
4687         ## Change orientation of the given object.
4688         #  @param theObject Shape to be processed.
4689         #  @return New GEOM.GEOM_Object, containing processed shape.
4690         #
4691         #  @ref swig_todo "Example"
4692         def ChangeOrientationShellCopy(self, theObject):
4693             """
4694             Change orientation of the given object.
4695
4696             Parameters:
4697                 theObject Shape to be processed.
4698
4699             Returns:
4700                 New GEOM.GEOM_Object, containing processed shape.
4701             """
4702             anObj = self.HealOp.ChangeOrientationCopy(theObject)
4703             RaiseIfFailed("ChangeOrientationCopy", self.HealOp)
4704             return anObj
4705
4706         ## Try to limit tolerance of the given object by value \a theTolerance.
4707         #  @param theObject Shape to be processed.
4708         #  @param theTolerance Required tolerance value.
4709         #  @return New GEOM.GEOM_Object, containing processed shape.
4710         #
4711         #  @ref tui_limit_tolerance "Example"
4712         def LimitTolerance(self, theObject, theTolerance = 1e-07):
4713             """
4714             Try to limit tolerance of the given object by value theTolerance.
4715
4716             Parameters:
4717                 theObject Shape to be processed.
4718                 theTolerance Required tolerance value.
4719
4720             Returns:
4721                 New GEOM.GEOM_Object, containing processed shape.
4722             """
4723             anObj = self.HealOp.LimitTolerance(theObject, theTolerance)
4724             RaiseIfFailed("LimitTolerance", self.HealOp)
4725             return anObj
4726
4727         ## Get a list of wires (wrapped in GEOM.GEOM_Object-s),
4728         #  that constitute a free boundary of the given shape.
4729         #  @param theObject Shape to get free boundary of.
4730         #  @return [\a status, \a theClosedWires, \a theOpenWires]
4731         #  \n \a status: FALSE, if an error(s) occured during the method execution.
4732         #  \n \a theClosedWires: Closed wires on the free boundary of the given shape.
4733         #  \n \a theOpenWires: Open wires on the free boundary of the given shape.
4734         #
4735         #  @ref tui_measurement_tools_page "Example"
4736         def GetFreeBoundary(self, theObject):
4737             """
4738             Get a list of wires (wrapped in GEOM.GEOM_Object-s),
4739             that constitute a free boundary of the given shape.
4740
4741             Parameters:
4742                 theObject Shape to get free boundary of.
4743
4744             Returns:
4745                 [status, theClosedWires, theOpenWires]
4746                  status: FALSE, if an error(s) occured during the method execution.
4747                  theClosedWires: Closed wires on the free boundary of the given shape.
4748                  theOpenWires: Open wires on the free boundary of the given shape.
4749             """
4750             # Example: see GEOM_TestHealing.py
4751             anObj = self.HealOp.GetFreeBoundary(theObject)
4752             RaiseIfFailed("GetFreeBoundary", self.HealOp)
4753             return anObj
4754
4755         ## Replace coincident faces in theShape by one face.
4756         #  @param theShape Initial shape.
4757         #  @param theTolerance Maximum distance between faces, which can be considered as coincident.
4758         #  @param doKeepNonSolids If FALSE, only solids will present in the result,
4759         #                         otherwise all initial shapes.
4760         #  @return New GEOM.GEOM_Object, containing a copy of theShape without coincident faces.
4761         #
4762         #  @ref tui_glue_faces "Example"
4763         def MakeGlueFaces(self, theShape, theTolerance, doKeepNonSolids=True):
4764             """
4765             Replace coincident faces in theShape by one face.
4766
4767             Parameters:
4768                 theShape Initial shape.
4769                 theTolerance Maximum distance between faces, which can be considered as coincident.
4770                 doKeepNonSolids If FALSE, only solids will present in the result,
4771                                 otherwise all initial shapes.
4772
4773             Returns:
4774                 New GEOM.GEOM_Object, containing a copy of theShape without coincident faces.
4775             """
4776             # Example: see GEOM_Spanner.py
4777             theTolerance,Parameters = ParseParameters(theTolerance)
4778             anObj = self.ShapesOp.MakeGlueFaces(theShape, theTolerance, doKeepNonSolids)
4779             if anObj is None:
4780                 raise RuntimeError, "MakeGlueFaces : " + self.ShapesOp.GetErrorCode()
4781             anObj.SetParameters(Parameters)
4782             return anObj
4783
4784         ## Find coincident faces in theShape for possible gluing.
4785         #  @param theShape Initial shape.
4786         #  @param theTolerance Maximum distance between faces,
4787         #                      which can be considered as coincident.
4788         #  @return GEOM.ListOfGO
4789         #
4790         #  @ref tui_glue_faces "Example"
4791         def GetGlueFaces(self, theShape, theTolerance):
4792             """
4793             Find coincident faces in theShape for possible gluing.
4794
4795             Parameters:
4796                 theShape Initial shape.
4797                 theTolerance Maximum distance between faces,
4798                              which can be considered as coincident.
4799
4800             Returns:
4801                 GEOM.ListOfGO
4802             """
4803             anObj = self.ShapesOp.GetGlueFaces(theShape, theTolerance)
4804             RaiseIfFailed("GetGlueFaces", self.ShapesOp)
4805             return anObj
4806
4807         ## Replace coincident faces in theShape by one face
4808         #  in compliance with given list of faces
4809         #  @param theShape Initial shape.
4810         #  @param theTolerance Maximum distance between faces,
4811         #                      which can be considered as coincident.
4812         #  @param theFaces List of faces for gluing.
4813         #  @param doKeepNonSolids If FALSE, only solids will present in the result,
4814         #                         otherwise all initial shapes.
4815         #  @param doGlueAllEdges If TRUE, all coincident edges of <VAR>theShape</VAR>
4816         #                        will be glued, otherwise only the edges,
4817         #                        belonging to <VAR>theFaces</VAR>.
4818         #  @return New GEOM.GEOM_Object, containing a copy of theShape
4819         #          without some faces.
4820         #
4821         #  @ref tui_glue_faces "Example"
4822         def MakeGlueFacesByList(self, theShape, theTolerance, theFaces,
4823                                 doKeepNonSolids=True, doGlueAllEdges=True):
4824             """
4825             Replace coincident faces in theShape by one face
4826             in compliance with given list of faces
4827
4828             Parameters:
4829                 theShape Initial shape.
4830                 theTolerance Maximum distance between faces,
4831                              which can be considered as coincident.
4832                 theFaces List of faces for gluing.
4833                 doKeepNonSolids If FALSE, only solids will present in the result,
4834                                 otherwise all initial shapes.
4835                 doGlueAllEdges If TRUE, all coincident edges of theShape
4836                                will be glued, otherwise only the edges,
4837                                belonging to theFaces.
4838
4839             Returns:
4840                 New GEOM.GEOM_Object, containing a copy of theShape
4841                     without some faces.
4842             """
4843             anObj = self.ShapesOp.MakeGlueFacesByList(theShape, theTolerance, theFaces,
4844                                                       doKeepNonSolids, doGlueAllEdges)
4845             if anObj is None:
4846                 raise RuntimeError, "MakeGlueFacesByList : " + self.ShapesOp.GetErrorCode()
4847             return anObj
4848
4849         ## Replace coincident edges in theShape by one edge.
4850         #  @param theShape Initial shape.
4851         #  @param theTolerance Maximum distance between edges, which can be considered as coincident.
4852         #  @return New GEOM.GEOM_Object, containing a copy of theShape without coincident edges.
4853         #
4854         #  @ref tui_glue_edges "Example"
4855         def MakeGlueEdges(self, theShape, theTolerance):
4856             """
4857             Replace coincident edges in theShape by one edge.
4858
4859             Parameters:
4860                 theShape Initial shape.
4861                 theTolerance Maximum distance between edges, which can be considered as coincident.
4862
4863             Returns:
4864                 New GEOM.GEOM_Object, containing a copy of theShape without coincident edges.
4865             """
4866             theTolerance,Parameters = ParseParameters(theTolerance)
4867             anObj = self.ShapesOp.MakeGlueEdges(theShape, theTolerance)
4868             if anObj is None:
4869                 raise RuntimeError, "MakeGlueEdges : " + self.ShapesOp.GetErrorCode()
4870             anObj.SetParameters(Parameters)
4871             return anObj
4872
4873         ## Find coincident edges in theShape for possible gluing.
4874         #  @param theShape Initial shape.
4875         #  @param theTolerance Maximum distance between edges,
4876         #                      which can be considered as coincident.
4877         #  @return GEOM.ListOfGO
4878         #
4879         #  @ref tui_glue_edges "Example"
4880         def GetGlueEdges(self, theShape, theTolerance):
4881             """
4882             Find coincident edges in theShape for possible gluing.
4883
4884             Parameters:
4885                 theShape Initial shape.
4886                 theTolerance Maximum distance between edges,
4887                              which can be considered as coincident.
4888
4889             Returns:
4890                 GEOM.ListOfGO
4891             """
4892             anObj = self.ShapesOp.GetGlueEdges(theShape, theTolerance)
4893             RaiseIfFailed("GetGlueEdges", self.ShapesOp)
4894             return anObj
4895
4896         ## Replace coincident edges in theShape by one edge
4897         #  in compliance with given list of edges.
4898         #  @param theShape Initial shape.
4899         #  @param theTolerance Maximum distance between edges,
4900         #                      which can be considered as coincident.
4901         #  @param theEdges List of edges for gluing.
4902         #  @return New GEOM.GEOM_Object, containing a copy of theShape
4903         #          without some edges.
4904         #
4905         #  @ref tui_glue_edges "Example"
4906         def MakeGlueEdgesByList(self, theShape, theTolerance, theEdges):
4907             """
4908             Replace coincident edges in theShape by one edge
4909             in compliance with given list of edges.
4910
4911             Parameters:
4912                 theShape Initial shape.
4913                 theTolerance Maximum distance between edges,
4914                              which can be considered as coincident.
4915                 theEdges List of edges for gluing.
4916
4917             Returns:
4918                 New GEOM.GEOM_Object, containing a copy of theShape
4919                 without some edges.
4920             """
4921             anObj = self.ShapesOp.MakeGlueEdgesByList(theShape, theTolerance, theEdges)
4922             if anObj is None:
4923                 raise RuntimeError, "MakeGlueEdgesByList : " + self.ShapesOp.GetErrorCode()
4924             return anObj
4925
4926         # end of l3_healing
4927         ## @}
4928
4929         ## @addtogroup l3_boolean Boolean Operations
4930         ## @{
4931
4932         # -----------------------------------------------------------------------------
4933         # Boolean (Common, Cut, Fuse, Section)
4934         # -----------------------------------------------------------------------------
4935
4936         ## Perform one of boolean operations on two given shapes.
4937         #  @param theShape1 First argument for boolean operation.
4938         #  @param theShape2 Second argument for boolean operation.
4939         #  @param theOperation Indicates the operation to be done:\n
4940         #                      1 - Common, 2 - Cut, 3 - Fuse, 4 - Section.
4941         #  @return New GEOM.GEOM_Object, containing the result shape.
4942         #
4943         #  @ref tui_fuse "Example"
4944         def MakeBoolean(self,theShape1, theShape2, theOperation):
4945             """
4946             Perform one of boolean operations on two given shapes.
4947
4948             Parameters:
4949                 theShape1 First argument for boolean operation.
4950                 theShape2 Second argument for boolean operation.
4951                 theOperation Indicates the operation to be done:
4952                              1 - Common, 2 - Cut, 3 - Fuse, 4 - Section.
4953
4954             Returns:
4955                 New GEOM.GEOM_Object, containing the result shape.
4956             """
4957             # Example: see GEOM_TestAll.py
4958             anObj = self.BoolOp.MakeBoolean(theShape1, theShape2, theOperation)
4959             RaiseIfFailed("MakeBoolean", self.BoolOp)
4960             return anObj
4961
4962         ## Perform Common boolean operation on two given shapes.
4963         #  @param theShape1 First argument for boolean operation.
4964         #  @param theShape2 Second argument for boolean operation.
4965         #  @return New GEOM.GEOM_Object, containing the result shape.
4966         #
4967         #  @ref tui_common "Example 1"
4968         #  \n @ref swig_MakeCommon "Example 2"
4969         def MakeCommon(self, theShape1, theShape2):
4970             """
4971             Perform Common boolean operation on two given shapes.
4972
4973             Parameters:
4974                 theShape1 First argument for boolean operation.
4975                 theShape2 Second argument for boolean operation.
4976
4977             Returns:
4978                 New GEOM.GEOM_Object, containing the result shape.
4979             """
4980             # Example: see GEOM_TestOthers.py
4981             return self.MakeBoolean(theShape1, theShape2, 1)
4982
4983         ## Perform Cut boolean operation on two given shapes.
4984         #  @param theShape1 First argument for boolean operation.
4985         #  @param theShape2 Second argument for boolean operation.
4986         #  @return New GEOM.GEOM_Object, containing the result shape.
4987         #
4988         #  @ref tui_cut "Example 1"
4989         #  \n @ref swig_MakeCommon "Example 2"
4990         def MakeCut(self, theShape1, theShape2):
4991             """
4992             Perform Cut boolean operation on two given shapes.
4993
4994             Parameters:
4995                 theShape1 First argument for boolean operation.
4996                 theShape2 Second argument for boolean operation.
4997
4998             Returns:
4999                 New GEOM.GEOM_Object, containing the result shape.
5000
5001             """
5002             # Example: see GEOM_TestOthers.py
5003             return self.MakeBoolean(theShape1, theShape2, 2)
5004
5005         ## Perform Fuse boolean operation on two given shapes.
5006         #  @param theShape1 First argument for boolean operation.
5007         #  @param theShape2 Second argument for boolean operation.
5008         #  @return New GEOM.GEOM_Object, containing the result shape.
5009         #
5010         #  @ref tui_fuse "Example 1"
5011         #  \n @ref swig_MakeCommon "Example 2"
5012         def MakeFuse(self, theShape1, theShape2):
5013             """
5014             Perform Fuse boolean operation on two given shapes.
5015
5016             Parameters:
5017                 theShape1 First argument for boolean operation.
5018                 theShape2 Second argument for boolean operation.
5019
5020             Returns:
5021                 New GEOM.GEOM_Object, containing the result shape.
5022
5023             """
5024             # Example: see GEOM_TestOthers.py
5025             return self.MakeBoolean(theShape1, theShape2, 3)
5026
5027         ## Perform Section boolean operation on two given shapes.
5028         #  @param theShape1 First argument for boolean operation.
5029         #  @param theShape2 Second argument for boolean operation.
5030         #  @return New GEOM.GEOM_Object, containing the result shape.
5031         #
5032         #  @ref tui_section "Example 1"
5033         #  \n @ref swig_MakeCommon "Example 2"
5034         def MakeSection(self, theShape1, theShape2):
5035             """
5036             Perform Section boolean operation on two given shapes.
5037
5038             Parameters:
5039                 theShape1 First argument for boolean operation.
5040                 theShape2 Second argument for boolean operation.
5041
5042             Returns:
5043                 New GEOM.GEOM_Object, containing the result shape.
5044
5045             """
5046             # Example: see GEOM_TestOthers.py
5047             return self.MakeBoolean(theShape1, theShape2, 4)
5048
5049         # end of l3_boolean
5050         ## @}
5051
5052         ## @addtogroup l3_basic_op
5053         ## @{
5054
5055         ## Perform partition operation.
5056         #  @param ListShapes Shapes to be intersected.
5057         #  @param ListTools Shapes to intersect theShapes.
5058         #  @param Limit Type of resulting shapes (see ShapeType()).\n
5059         #         If this parameter is set to -1 ("Auto"), most appropriate shape limit
5060         #         type will be detected automatically.
5061         #  @param KeepNonlimitShapes if this parameter == 0, then only shapes of
5062         #                             target type (equal to Limit) are kept in the result,
5063         #                             else standalone shapes of lower dimension
5064         #                             are kept also (if they exist).
5065         #  @note Each compound from ListShapes and ListTools will be exploded
5066         #        in order to avoid possible intersection between shapes from this compound.
5067         #
5068         #  After implementation new version of PartitionAlgo (October 2006)
5069         #  other parameters are ignored by current functionality. They are kept
5070         #  in this function only for support old versions.
5071         #      @param ListKeepInside Shapes, outside which the results will be deleted.
5072         #         Each shape from theKeepInside must belong to theShapes also.
5073         #      @param ListRemoveInside Shapes, inside which the results will be deleted.
5074         #         Each shape from theRemoveInside must belong to theShapes also.
5075         #      @param RemoveWebs If TRUE, perform Glue 3D algorithm.
5076         #      @param ListMaterials Material indices for each shape. Make sence,
5077         #         only if theRemoveWebs is TRUE.
5078         #
5079         #  @return New GEOM.GEOM_Object, containing the result shapes.
5080         #
5081         #  @ref tui_partition "Example"
5082         def MakePartition(self, ListShapes, ListTools=[], ListKeepInside=[], ListRemoveInside=[],
5083                           Limit=ShapeType["AUTO"], RemoveWebs=0, ListMaterials=[],
5084                           KeepNonlimitShapes=0):
5085             """
5086             Perform partition operation.
5087
5088             Parameters:
5089                 ListShapes Shapes to be intersected.
5090                 ListTools Shapes to intersect theShapes.
5091                 Limit Type of resulting shapes (see geompy.ShapeType)
5092                       If this parameter is set to -1 ("Auto"), most appropriate shape limit
5093                       type will be detected automatically.
5094                 KeepNonlimitShapes if this parameter == 0, then only shapes of
5095                                     target type (equal to Limit) are kept in the result,
5096                                     else standalone shapes of lower dimension
5097                                     are kept also (if they exist).
5098             Note:
5099                     Each compound from ListShapes and ListTools will be exploded
5100                     in order to avoid possible intersection between shapes from
5101                     this compound.
5102
5103             After implementation new version of PartitionAlgo (October 2006) other
5104             parameters are ignored by current functionality. They are kept in this
5105             function only for support old versions.
5106
5107             Ignored parameters:
5108                 ListKeepInside Shapes, outside which the results will be deleted.
5109                                Each shape from theKeepInside must belong to theShapes also.
5110                 ListRemoveInside Shapes, inside which the results will be deleted.
5111                                  Each shape from theRemoveInside must belong to theShapes also.
5112                 RemoveWebs If TRUE, perform Glue 3D algorithm.
5113                 ListMaterials Material indices for each shape. Make sence, only if theRemoveWebs is TRUE.
5114
5115             Returns:
5116                 New GEOM.GEOM_Object, containing the result shapes.
5117             """
5118             # Example: see GEOM_TestAll.py
5119             if Limit == ShapeType["AUTO"]:
5120                 # automatic detection of the most appropriate shape limit type
5121                 lim = GEOM.SHAPE
5122                 for s in ListShapes: lim = min( lim, s.GetMaxShapeType() )
5123                 Limit = EnumToLong(lim)
5124                 pass
5125             anObj = self.BoolOp.MakePartition(ListShapes, ListTools,
5126                                               ListKeepInside, ListRemoveInside,
5127                                               Limit, RemoveWebs, ListMaterials,
5128                                               KeepNonlimitShapes);
5129             RaiseIfFailed("MakePartition", self.BoolOp)
5130             return anObj
5131
5132         ## Perform partition operation.
5133         #  This method may be useful if it is needed to make a partition for
5134         #  compound contains nonintersected shapes. Performance will be better
5135         #  since intersection between shapes from compound is not performed.
5136         #
5137         #  Description of all parameters as in previous method MakePartition()
5138         #
5139         #  @note Passed compounds (via ListShapes or via ListTools)
5140         #           have to consist of nonintersecting shapes.
5141         #
5142         #  @return New GEOM.GEOM_Object, containing the result shapes.
5143         #
5144         #  @ref swig_todo "Example"
5145         def MakePartitionNonSelfIntersectedShape(self, ListShapes, ListTools=[],
5146                                                  ListKeepInside=[], ListRemoveInside=[],
5147                                                  Limit=ShapeType["AUTO"], RemoveWebs=0,
5148                                                  ListMaterials=[], KeepNonlimitShapes=0):
5149             """
5150             Perform partition operation.
5151             This method may be useful if it is needed to make a partition for
5152             compound contains nonintersected shapes. Performance will be better
5153             since intersection between shapes from compound is not performed.
5154
5155             Parameters:
5156                 Description of all parameters as in method geompy.MakePartition
5157
5158             NOTE:
5159                 Passed compounds (via ListShapes or via ListTools)
5160                 have to consist of nonintersecting shapes.
5161
5162             Returns:
5163                 New GEOM.GEOM_Object, containing the result shapes.
5164             """
5165             if Limit == ShapeType["AUTO"]:
5166                 # automatic detection of the most appropriate shape limit type
5167                 lim = GEOM.SHAPE
5168                 for s in ListShapes: lim = min( lim, s.GetMaxShapeType() )
5169                 Limit = EnumToLong(lim)
5170                 pass
5171             anObj = self.BoolOp.MakePartitionNonSelfIntersectedShape(ListShapes, ListTools,
5172                                                                      ListKeepInside, ListRemoveInside,
5173                                                                      Limit, RemoveWebs, ListMaterials,
5174                                                                      KeepNonlimitShapes);
5175             RaiseIfFailed("MakePartitionNonSelfIntersectedShape", self.BoolOp)
5176             return anObj
5177
5178         ## See method MakePartition() for more information.
5179         #
5180         #  @ref tui_partition "Example 1"
5181         #  \n @ref swig_Partition "Example 2"
5182         def Partition(self, ListShapes, ListTools=[], ListKeepInside=[], ListRemoveInside=[],
5183                       Limit=ShapeType["AUTO"], RemoveWebs=0, ListMaterials=[],
5184                       KeepNonlimitShapes=0):
5185             """
5186             See method geompy.MakePartition for more information.
5187             """
5188             # Example: see GEOM_TestOthers.py
5189             anObj = self.MakePartition(ListShapes, ListTools,
5190                                        ListKeepInside, ListRemoveInside,
5191                                        Limit, RemoveWebs, ListMaterials,
5192                                        KeepNonlimitShapes);
5193             return anObj
5194
5195         ## Perform partition of the Shape with the Plane
5196         #  @param theShape Shape to be intersected.
5197         #  @param thePlane Tool shape, to intersect theShape.
5198         #  @return New GEOM.GEOM_Object, containing the result shape.
5199         #
5200         #  @ref tui_partition "Example"
5201         def MakeHalfPartition(self,theShape, thePlane):
5202             """
5203             Perform partition of the Shape with the Plane
5204
5205             Parameters:
5206                 theShape Shape to be intersected.
5207                 thePlane Tool shape, to intersect theShape.
5208
5209             Returns:
5210                 New GEOM.GEOM_Object, containing the result shape.
5211             """
5212             # Example: see GEOM_TestAll.py
5213             anObj = self.BoolOp.MakeHalfPartition(theShape, thePlane)
5214             RaiseIfFailed("MakeHalfPartition", self.BoolOp)
5215             return anObj
5216
5217         # end of l3_basic_op
5218         ## @}
5219
5220         ## @addtogroup l3_transform
5221         ## @{
5222
5223         ## Translate the given object along the vector, specified
5224         #  by its end points, creating its copy before the translation.
5225         #  @param theObject The object to be translated.
5226         #  @param thePoint1 Start point of translation vector.
5227         #  @param thePoint2 End point of translation vector.
5228         #  @return New GEOM.GEOM_Object, containing the translated object.
5229         #
5230         #  @ref tui_translation "Example 1"
5231         #  \n @ref swig_MakeTranslationTwoPoints "Example 2"
5232         def MakeTranslationTwoPoints(self,theObject, thePoint1, thePoint2):
5233             """
5234             Translate the given object along the vector, specified
5235             by its end points, creating its copy before the translation.
5236
5237             Parameters:
5238                 theObject The object to be translated.
5239                 thePoint1 Start point of translation vector.
5240                 thePoint2 End point of translation vector.
5241
5242             Returns:
5243                 New GEOM.GEOM_Object, containing the translated object.
5244             """
5245             # Example: see GEOM_TestAll.py
5246             anObj = self.TrsfOp.TranslateTwoPointsCopy(theObject, thePoint1, thePoint2)
5247             RaiseIfFailed("TranslateTwoPointsCopy", self.TrsfOp)
5248             return anObj
5249
5250         ## Translate the given object along the vector, specified by its components.
5251         #  @param theObject The object to be translated.
5252         #  @param theDX,theDY,theDZ Components of translation vector.
5253         #  @return Translated GEOM.GEOM_Object.
5254         #
5255         #  @ref tui_translation "Example"
5256         def TranslateDXDYDZ(self,theObject, theDX, theDY, theDZ):
5257             """
5258             Translate the given object along the vector, specified by its components.
5259
5260             Parameters:
5261                 theObject The object to be translated.
5262                 theDX,theDY,theDZ Components of translation vector.
5263
5264             Returns:
5265                 Translated GEOM.GEOM_Object.
5266             """
5267             # Example: see GEOM_TestAll.py
5268             theDX, theDY, theDZ, Parameters = ParseParameters(theDX, theDY, theDZ)
5269             anObj = self.TrsfOp.TranslateDXDYDZ(theObject, theDX, theDY, theDZ)
5270             anObj.SetParameters(Parameters)
5271             RaiseIfFailed("TranslateDXDYDZ", self.TrsfOp)
5272             return anObj
5273
5274         ## Translate the given object along the vector, specified
5275         #  by its components, creating its copy before the translation.
5276         #  @param theObject The object to be translated.
5277         #  @param theDX,theDY,theDZ Components of translation vector.
5278         #  @return New GEOM.GEOM_Object, containing the translated object.
5279         #
5280         #  @ref tui_translation "Example"
5281         def MakeTranslation(self,theObject, theDX, theDY, theDZ):
5282             """
5283             Translate the given object along the vector, specified
5284             by its components, creating its copy before the translation.
5285
5286             Parameters:
5287                 theObject The object to be translated.
5288                 theDX,theDY,theDZ Components of translation vector.
5289
5290             Returns:
5291                 New GEOM.GEOM_Object, containing the translated object.
5292             """
5293             # Example: see GEOM_TestAll.py
5294             theDX, theDY, theDZ, Parameters = ParseParameters(theDX, theDY, theDZ)
5295             anObj = self.TrsfOp.TranslateDXDYDZCopy(theObject, theDX, theDY, theDZ)
5296             anObj.SetParameters(Parameters)
5297             RaiseIfFailed("TranslateDXDYDZ", self.TrsfOp)
5298             return anObj
5299
5300         ## Translate the given object along the given vector,
5301         #  creating its copy before the translation.
5302         #  @param theObject The object to be translated.
5303         #  @param theVector The translation vector.
5304         #  @return New GEOM.GEOM_Object, containing the translated object.
5305         #
5306         #  @ref tui_translation "Example"
5307         def MakeTranslationVector(self,theObject, theVector):
5308             """
5309             Translate the given object along the given vector,
5310             creating its copy before the translation.
5311
5312             Parameters:
5313                 theObject The object to be translated.
5314                 theVector The translation vector.
5315
5316             Returns:
5317                 New GEOM.GEOM_Object, containing the translated object.
5318             """
5319             # Example: see GEOM_TestAll.py
5320             anObj = self.TrsfOp.TranslateVectorCopy(theObject, theVector)
5321             RaiseIfFailed("TranslateVectorCopy", self.TrsfOp)
5322             return anObj
5323
5324         ## Translate the given object along the given vector on given distance.
5325         #  @param theObject The object to be translated.
5326         #  @param theVector The translation vector.
5327         #  @param theDistance The translation distance.
5328         #  @param theCopy Flag used to translate object itself or create a copy.
5329         #  @return New GEOM.GEOM_Object, containing the translated object.
5330         #
5331         #  @ref tui_translation "Example"
5332         def TranslateVectorDistance(self, theObject, theVector, theDistance, theCopy):
5333             """
5334             Translate the given object along the given vector on given distance.
5335
5336             Parameters:
5337                 theObject The object to be translated.
5338                 theVector The translation vector.
5339                 theDistance The translation distance.
5340                 theCopy Flag used to translate object itself or create a copy.
5341
5342             Returns:
5343                 New GEOM.GEOM_Object, containing the translated object.
5344             """
5345             # Example: see GEOM_TestAll.py
5346             theDistance,Parameters = ParseParameters(theDistance)
5347             anObj = self.TrsfOp.TranslateVectorDistance(theObject, theVector, theDistance, theCopy)
5348             RaiseIfFailed("TranslateVectorDistance", self.TrsfOp)
5349             anObj.SetParameters(Parameters)
5350             return anObj
5351
5352         ## Translate the given object along the given vector on given distance,
5353         #  creating its copy before the translation.
5354         #  @param theObject The object to be translated.
5355         #  @param theVector The translation vector.
5356         #  @param theDistance The translation distance.
5357         #  @return New GEOM.GEOM_Object, containing the translated object.
5358         #
5359         #  @ref tui_translation "Example"
5360         def MakeTranslationVectorDistance(self, theObject, theVector, theDistance):
5361             """
5362             Translate the given object along the given vector on given distance,
5363             creating its copy before the translation.
5364
5365             Parameters:
5366                 theObject The object to be translated.
5367                 theVector The translation vector.
5368                 theDistance The translation distance.
5369
5370             Returns:
5371                 New GEOM.GEOM_Object, containing the translated object.
5372             """
5373             # Example: see GEOM_TestAll.py
5374             theDistance,Parameters = ParseParameters(theDistance)
5375             anObj = self.TrsfOp.TranslateVectorDistance(theObject, theVector, theDistance, 1)
5376             RaiseIfFailed("TranslateVectorDistance", self.TrsfOp)
5377             anObj.SetParameters(Parameters)
5378             return anObj
5379
5380         ## Rotate the given object around the given axis on the given angle.
5381         #  @param theObject The object to be rotated.
5382         #  @param theAxis Rotation axis.
5383         #  @param theAngle Rotation angle in radians.
5384         #  @return New GEOM.GEOM_Object, containing the rotated object.
5385         #
5386         #  @ref tui_rotation "Example"
5387         def Rotate(self,theObject, theAxis, theAngle):
5388             """
5389             Rotate the given object around the given axis on the given angle.
5390
5391             Parameters:
5392                 theObject The object to be rotated.
5393                 theAxis Rotation axis.
5394                 theAngle Rotation angle in radians.
5395
5396             Returns:
5397                 New GEOM.GEOM_Object, containing the rotated object.
5398             """
5399             # Example: see GEOM_TestAll.py
5400             flag = False
5401             if isinstance(theAngle,str):
5402                 flag = True
5403             theAngle, Parameters = ParseParameters(theAngle)
5404             if flag:
5405                 theAngle = theAngle*math.pi/180.0
5406             anObj = self.TrsfOp.Rotate(theObject, theAxis, theAngle)
5407             RaiseIfFailed("RotateCopy", self.TrsfOp)
5408             anObj.SetParameters(Parameters)
5409             return anObj
5410
5411         ## Rotate the given object around the given axis
5412         #  on the given angle, creating its copy before the rotatation.
5413         #  @param theObject The object to be rotated.
5414         #  @param theAxis Rotation axis.
5415         #  @param theAngle Rotation angle in radians.
5416         #  @return New GEOM.GEOM_Object, containing the rotated object.
5417         #
5418         #  @ref tui_rotation "Example"
5419         def MakeRotation(self,theObject, theAxis, theAngle):
5420             """
5421             Rotate the given object around the given axis
5422             on the given angle, creating its copy before the rotatation.
5423
5424             Parameters:
5425                 theObject The object to be rotated.
5426                 theAxis Rotation axis.
5427                 theAngle Rotation angle in radians.
5428
5429             Returns:
5430                 New GEOM.GEOM_Object, containing the rotated object.
5431             """
5432             # Example: see GEOM_TestAll.py
5433             flag = False
5434             if isinstance(theAngle,str):
5435                 flag = True
5436             theAngle, Parameters = ParseParameters(theAngle)
5437             if flag:
5438                 theAngle = theAngle*math.pi/180.0
5439             anObj = self.TrsfOp.RotateCopy(theObject, theAxis, theAngle)
5440             RaiseIfFailed("RotateCopy", self.TrsfOp)
5441             anObj.SetParameters(Parameters)
5442             return anObj
5443
5444         ## Rotate given object around vector perpendicular to plane
5445         #  containing three points, creating its copy before the rotatation.
5446         #  @param theObject The object to be rotated.
5447         #  @param theCentPoint central point the axis is the vector perpendicular to the plane
5448         #  containing the three points.
5449         #  @param thePoint1,thePoint2 in a perpendicular plane of the axis.
5450         #  @return New GEOM.GEOM_Object, containing the rotated object.
5451         #
5452         #  @ref tui_rotation "Example"
5453         def MakeRotationThreePoints(self,theObject, theCentPoint, thePoint1, thePoint2):
5454             """
5455             Rotate given object around vector perpendicular to plane
5456             containing three points, creating its copy before the rotatation.
5457
5458             Parameters:
5459                 theObject The object to be rotated.
5460                 theCentPoint central point  the axis is the vector perpendicular to the plane
5461                              containing the three points.
5462                 thePoint1,thePoint2  in a perpendicular plane of the axis.
5463
5464             Returns:
5465                 New GEOM.GEOM_Object, containing the rotated object.
5466             """
5467             # Example: see GEOM_TestAll.py
5468             anObj = self.TrsfOp.RotateThreePointsCopy(theObject, theCentPoint, thePoint1, thePoint2)
5469             RaiseIfFailed("RotateThreePointsCopy", self.TrsfOp)
5470             return anObj
5471
5472         ## Scale the given object by the factor, creating its copy before the scaling.
5473         #  @param theObject The object to be scaled.
5474         #  @param thePoint Center point for scaling.
5475         #                  Passing None for it means scaling relatively the origin of global CS.
5476         #  @param theFactor Scaling factor value.
5477         #  @return New GEOM.GEOM_Object, containing the scaled shape.
5478         #
5479         #  @ref tui_scale "Example"
5480         def MakeScaleTransform(self, theObject, thePoint, theFactor):
5481             """
5482             Scale the given object by the factor, creating its copy before the scaling.
5483
5484             Parameters:
5485                 theObject The object to be scaled.
5486                 thePoint Center point for scaling.
5487                          Passing None for it means scaling relatively the origin of global CS.
5488                 theFactor Scaling factor value.
5489
5490             Returns:
5491                 New GEOM.GEOM_Object, containing the scaled shape.
5492             """
5493             # Example: see GEOM_TestAll.py
5494             theFactor, Parameters = ParseParameters(theFactor)
5495             anObj = self.TrsfOp.ScaleShapeCopy(theObject, thePoint, theFactor)
5496             RaiseIfFailed("ScaleShapeCopy", self.TrsfOp)
5497             anObj.SetParameters(Parameters)
5498             return anObj
5499
5500         ## Scale the given object by different factors along coordinate axes,
5501         #  creating its copy before the scaling.
5502         #  @param theObject The object to be scaled.
5503         #  @param thePoint Center point for scaling.
5504         #                  Passing None for it means scaling relatively the origin of global CS.
5505         #  @param theFactorX,theFactorY,theFactorZ Scaling factors along each axis.
5506         #  @return New GEOM.GEOM_Object, containing the scaled shape.
5507         #
5508         #  @ref swig_scale "Example"
5509         def MakeScaleAlongAxes(self, theObject, thePoint, theFactorX, theFactorY, theFactorZ):
5510             """
5511             Scale the given object by different factors along coordinate axes,
5512             creating its copy before the scaling.
5513
5514             Parameters:
5515                 theObject The object to be scaled.
5516                 thePoint Center point for scaling.
5517                             Passing None for it means scaling relatively the origin of global CS.
5518                 theFactorX,theFactorY,theFactorZ Scaling factors along each axis.
5519
5520             Returns:
5521                 New GEOM.GEOM_Object, containing the scaled shape.
5522             """
5523             # Example: see GEOM_TestAll.py
5524             theFactorX, theFactorY, theFactorZ, Parameters = ParseParameters(theFactorX, theFactorY, theFactorZ)
5525             anObj = self.TrsfOp.ScaleShapeAlongAxesCopy(theObject, thePoint,
5526                                                         theFactorX, theFactorY, theFactorZ)
5527             RaiseIfFailed("MakeScaleAlongAxes", self.TrsfOp)
5528             anObj.SetParameters(Parameters)
5529             return anObj
5530
5531         ## Create an object, symmetrical
5532         #  to the given one relatively the given plane.
5533         #  @param theObject The object to be mirrored.
5534         #  @param thePlane Plane of symmetry.
5535         #  @return New GEOM.GEOM_Object, containing the mirrored shape.
5536         #
5537         #  @ref tui_mirror "Example"
5538         def MakeMirrorByPlane(self,theObject, thePlane):
5539             """
5540             Create an object, symmetrical to the given one relatively the given plane.
5541
5542             Parameters:
5543                 theObject The object to be mirrored.
5544                 thePlane Plane of symmetry.
5545
5546             Returns:
5547                 New GEOM.GEOM_Object, containing the mirrored shape.
5548             """
5549             # Example: see GEOM_TestAll.py
5550             anObj = self.TrsfOp.MirrorPlaneCopy(theObject, thePlane)
5551             RaiseIfFailed("MirrorPlaneCopy", self.TrsfOp)
5552             return anObj
5553
5554         ## Create an object, symmetrical
5555         #  to the given one relatively the given axis.
5556         #  @param theObject The object to be mirrored.
5557         #  @param theAxis Axis of symmetry.
5558         #  @return New GEOM.GEOM_Object, containing the mirrored shape.
5559         #
5560         #  @ref tui_mirror "Example"
5561         def MakeMirrorByAxis(self,theObject, theAxis):
5562             """
5563             Create an object, symmetrical to the given one relatively the given axis.
5564
5565             Parameters:
5566                 theObject The object to be mirrored.
5567                 theAxis Axis of symmetry.
5568
5569             Returns:
5570                 New GEOM.GEOM_Object, containing the mirrored shape.
5571             """
5572             # Example: see GEOM_TestAll.py
5573             anObj = self.TrsfOp.MirrorAxisCopy(theObject, theAxis)
5574             RaiseIfFailed("MirrorAxisCopy", self.TrsfOp)
5575             return anObj
5576
5577         ## Create an object, symmetrical
5578         #  to the given one relatively the given point.
5579         #  @param theObject The object to be mirrored.
5580         #  @param thePoint Point of symmetry.
5581         #  @return New GEOM.GEOM_Object, containing the mirrored shape.
5582         #
5583         #  @ref tui_mirror "Example"
5584         def MakeMirrorByPoint(self,theObject, thePoint):
5585             """
5586             Create an object, symmetrical
5587             to the given one relatively the given point.
5588
5589             Parameters:
5590                 theObject The object to be mirrored.
5591                 thePoint Point of symmetry.
5592
5593             Returns:
5594                 New GEOM.GEOM_Object, containing the mirrored shape.
5595             """
5596             # Example: see GEOM_TestAll.py
5597             anObj = self.TrsfOp.MirrorPointCopy(theObject, thePoint)
5598             RaiseIfFailed("MirrorPointCopy", self.TrsfOp)
5599             return anObj
5600
5601         ## Modify the Location of the given object by LCS,
5602         #  creating its copy before the setting.
5603         #  @param theObject The object to be displaced.
5604         #  @param theStartLCS Coordinate system to perform displacement from it.\n
5605         #                     If \a theStartLCS is NULL, displacement
5606         #                     will be performed from global CS.\n
5607         #                     If \a theObject itself is used as \a theStartLCS,
5608         #                     its location will be changed to \a theEndLCS.
5609         #  @param theEndLCS Coordinate system to perform displacement to it.
5610         #  @return New GEOM.GEOM_Object, containing the displaced shape.
5611         #
5612         #  @ref tui_modify_location "Example"
5613         def MakePosition(self,theObject, theStartLCS, theEndLCS):
5614             """
5615             Modify the Location of the given object by LCS, creating its copy before the setting.
5616
5617             Parameters:
5618                 theObject The object to be displaced.
5619                 theStartLCS Coordinate system to perform displacement from it.
5620                             If theStartLCS is NULL, displacement
5621                             will be performed from global CS.
5622                             If theObject itself is used as theStartLCS,
5623                             its location will be changed to theEndLCS.
5624                 theEndLCS Coordinate system to perform displacement to it.
5625
5626             Returns:
5627                 New GEOM.GEOM_Object, containing the displaced shape.
5628
5629             Example of usage:
5630                 # create local coordinate systems
5631                 cs1 = geompy.MakeMarker( 0, 0, 0, 1,0,0, 0,1,0)
5632                 cs2 = geompy.MakeMarker(30,40,40, 1,0,0, 0,1,0)
5633                 # modify the location of the given object
5634                 position = geompy.MakePosition(cylinder, cs1, cs2)
5635             """
5636             # Example: see GEOM_TestAll.py
5637             anObj = self.TrsfOp.PositionShapeCopy(theObject, theStartLCS, theEndLCS)
5638             RaiseIfFailed("PositionShapeCopy", self.TrsfOp)
5639             return anObj
5640
5641         ## Modify the Location of the given object by Path,
5642         #  @param  theObject The object to be displaced.
5643         #  @param  thePath Wire or Edge along that the object will be translated.
5644         #  @param  theDistance progress of Path (0 = start location, 1 = end of path location).
5645         #  @param  theCopy is to create a copy objects if true.
5646         #  @param  theReverse  0 - for usual direction, 1 - to reverse path direction.
5647         #  @return New GEOM.GEOM_Object, containing the displaced shape.
5648         #
5649         #  @ref tui_modify_location "Example"
5650         def PositionAlongPath(self,theObject, thePath, theDistance, theCopy, theReverse):
5651             """
5652             Modify the Location of the given object by Path
5653
5654             Parameters:
5655                  theObject The object to be displaced.
5656                  thePath Wire or Edge along that the object will be translated.
5657                  theDistance progress of Path (0 = start location, 1 = end of path location).
5658                  theCopy is to create a copy objects if true.
5659                  theReverse  0 - for usual direction, 1 - to reverse path direction.
5660
5661             Returns:
5662                 New GEOM.GEOM_Object, containing the displaced shape.
5663
5664             Example of usage:
5665                 position = geompy.PositionAlongPath(cylinder, circle, 0.75, 1, 1)
5666             """
5667             # Example: see GEOM_TestAll.py
5668             anObj = self.TrsfOp.PositionAlongPath(theObject, thePath, theDistance, theCopy, theReverse)
5669             RaiseIfFailed("PositionAlongPath", self.TrsfOp)
5670             return anObj
5671
5672         ## Create new object as offset of the given one.
5673         #  @param theObject The base object for the offset.
5674         #  @param theOffset Offset value.
5675         #  @return New GEOM.GEOM_Object, containing the offset object.
5676         #
5677         #  @ref tui_offset "Example"
5678         def MakeOffset(self,theObject, theOffset):
5679             """
5680             Create new object as offset of the given one.
5681
5682             Parameters:
5683                 theObject The base object for the offset.
5684                 theOffset Offset value.
5685
5686             Returns:
5687                 New GEOM.GEOM_Object, containing the offset object.
5688
5689             Example of usage:
5690                  box = geompy.MakeBox(20, 20, 20, 200, 200, 200)
5691                  # create a new object as offset of the given object
5692                  offset = geompy.MakeOffset(box, 70.)
5693             """
5694             # Example: see GEOM_TestAll.py
5695             theOffset, Parameters = ParseParameters(theOffset)
5696             anObj = self.TrsfOp.OffsetShapeCopy(theObject, theOffset)
5697             RaiseIfFailed("OffsetShapeCopy", self.TrsfOp)
5698             anObj.SetParameters(Parameters)
5699             return anObj
5700
5701         ## Create new object as projection of the given one on a 2D surface.
5702         #  @param theSource The source object for the projection. It can be a point, edge or wire.
5703         #  @param theTarget The target object. It can be planar or cylindrical face.
5704         #  @return New GEOM.GEOM_Object, containing the projection.
5705         #
5706         #  @ref tui_projection "Example"
5707         def MakeProjection(self, theSource, theTarget):
5708             """
5709             Create new object as projection of the given one on a 2D surface.
5710
5711             Parameters:
5712                 theSource The source object for the projection. It can be a point, edge or wire.
5713                 theTarget The target object. It can be planar or cylindrical face.
5714
5715             Returns:
5716                 New GEOM.GEOM_Object, containing the projection.
5717             """
5718             # Example: see GEOM_TestAll.py
5719             anObj = self.TrsfOp.ProjectShapeCopy(theSource, theTarget)
5720             RaiseIfFailed("ProjectShapeCopy", self.TrsfOp)
5721             return anObj
5722
5723         # -----------------------------------------------------------------------------
5724         # Patterns
5725         # -----------------------------------------------------------------------------
5726
5727         ## Translate the given object along the given vector a given number times
5728         #  @param theObject The object to be translated.
5729         #  @param theVector Direction of the translation.
5730         #  @param theStep Distance to translate on.
5731         #  @param theNbTimes Quantity of translations to be done.
5732         #  @return New GEOM.GEOM_Object, containing compound of all
5733         #          the shapes, obtained after each translation.
5734         #
5735         #  @ref tui_multi_translation "Example"
5736         def MakeMultiTranslation1D(self,theObject, theVector, theStep, theNbTimes):
5737             """
5738             Translate the given object along the given vector a given number times
5739
5740             Parameters:
5741                 theObject The object to be translated.
5742                 theVector Direction of the translation.
5743                 theStep Distance to translate on.
5744                 theNbTimes Quantity of translations to be done.
5745
5746             Returns:
5747                 New GEOM.GEOM_Object, containing compound of all
5748                 the shapes, obtained after each translation.
5749
5750             Example of usage:
5751                 r1d = geompy.MakeMultiTranslation1D(prism, vect, 20, 4)
5752             """
5753             # Example: see GEOM_TestAll.py
5754             theStep, theNbTimes, Parameters = ParseParameters(theStep, theNbTimes)
5755             anObj = self.TrsfOp.MultiTranslate1D(theObject, theVector, theStep, theNbTimes)
5756             RaiseIfFailed("MultiTranslate1D", self.TrsfOp)
5757             anObj.SetParameters(Parameters)
5758             return anObj
5759
5760         ## Conseqently apply two specified translations to theObject specified number of times.
5761         #  @param theObject The object to be translated.
5762         #  @param theVector1 Direction of the first translation.
5763         #  @param theStep1 Step of the first translation.
5764         #  @param theNbTimes1 Quantity of translations to be done along theVector1.
5765         #  @param theVector2 Direction of the second translation.
5766         #  @param theStep2 Step of the second translation.
5767         #  @param theNbTimes2 Quantity of translations to be done along theVector2.
5768         #  @return New GEOM.GEOM_Object, containing compound of all
5769         #          the shapes, obtained after each translation.
5770         #
5771         #  @ref tui_multi_translation "Example"
5772         def MakeMultiTranslation2D(self,theObject, theVector1, theStep1, theNbTimes1,
5773                                    theVector2, theStep2, theNbTimes2):
5774             """
5775             Conseqently apply two specified translations to theObject specified number of times.
5776
5777             Parameters:
5778                 theObject The object to be translated.
5779                 theVector1 Direction of the first translation.
5780                 theStep1 Step of the first translation.
5781                 theNbTimes1 Quantity of translations to be done along theVector1.
5782                 theVector2 Direction of the second translation.
5783                 theStep2 Step of the second translation.
5784                 theNbTimes2 Quantity of translations to be done along theVector2.
5785
5786             Returns:
5787                 New GEOM.GEOM_Object, containing compound of all
5788                 the shapes, obtained after each translation.
5789
5790             Example of usage:
5791                 tr2d = geompy.MakeMultiTranslation2D(prism, vect1, 20, 4, vect2, 80, 3)
5792             """
5793             # Example: see GEOM_TestAll.py
5794             theStep1,theNbTimes1,theStep2,theNbTimes2, Parameters = ParseParameters(theStep1,theNbTimes1,theStep2,theNbTimes2)
5795             anObj = self.TrsfOp.MultiTranslate2D(theObject, theVector1, theStep1, theNbTimes1,
5796                                                  theVector2, theStep2, theNbTimes2)
5797             RaiseIfFailed("MultiTranslate2D", self.TrsfOp)
5798             anObj.SetParameters(Parameters)
5799             return anObj
5800
5801         ## Rotate the given object around the given axis a given number times.
5802         #  Rotation angle will be 2*PI/theNbTimes.
5803         #  @param theObject The object to be rotated.
5804         #  @param theAxis The rotation axis.
5805         #  @param theNbTimes Quantity of rotations to be done.
5806         #  @return New GEOM.GEOM_Object, containing compound of all the
5807         #          shapes, obtained after each rotation.
5808         #
5809         #  @ref tui_multi_rotation "Example"
5810         def MultiRotate1D(self,theObject, theAxis, theNbTimes):
5811             """
5812             Rotate the given object around the given axis a given number times.
5813             Rotation angle will be 2*PI/theNbTimes.
5814
5815             Parameters:
5816                 theObject The object to be rotated.
5817                 theAxis The rotation axis.
5818                 theNbTimes Quantity of rotations to be done.
5819
5820             Returns:
5821                 New GEOM.GEOM_Object, containing compound of all the
5822                 shapes, obtained after each rotation.
5823
5824             Example of usage:
5825                 rot1d = geompy.MultiRotate1D(prism, vect, 4)
5826             """
5827             # Example: see GEOM_TestAll.py
5828             theAxis, theNbTimes, Parameters = ParseParameters(theAxis, theNbTimes)
5829             anObj = self.TrsfOp.MultiRotate1D(theObject, theAxis, theNbTimes)
5830             RaiseIfFailed("MultiRotate1D", self.TrsfOp)
5831             anObj.SetParameters(Parameters)
5832             return anObj
5833
5834         ## Rotate the given object around the
5835         #  given axis on the given angle a given number
5836         #  times and multi-translate each rotation result.
5837         #  Translation direction passes through center of gravity
5838         #  of rotated shape and its projection on the rotation axis.
5839         #  @param theObject The object to be rotated.
5840         #  @param theAxis Rotation axis.
5841         #  @param theAngle Rotation angle in graduces.
5842         #  @param theNbTimes1 Quantity of rotations to be done.
5843         #  @param theStep Translation distance.
5844         #  @param theNbTimes2 Quantity of translations to be done.
5845         #  @return New GEOM.GEOM_Object, containing compound of all the
5846         #          shapes, obtained after each transformation.
5847         #
5848         #  @ref tui_multi_rotation "Example"
5849         def MultiRotate2D(self,theObject, theAxis, theAngle, theNbTimes1, theStep, theNbTimes2):
5850             """
5851             Rotate the given object around the
5852             given axis on the given angle a given number
5853             times and multi-translate each rotation result.
5854             Translation direction passes through center of gravity
5855             of rotated shape and its projection on the rotation axis.
5856
5857             Parameters:
5858                 theObject The object to be rotated.
5859                 theAxis Rotation axis.
5860                 theAngle Rotation angle in graduces.
5861                 theNbTimes1 Quantity of rotations to be done.
5862                 theStep Translation distance.
5863                 theNbTimes2 Quantity of translations to be done.
5864
5865             Returns:
5866                 New GEOM.GEOM_Object, containing compound of all the
5867                 shapes, obtained after each transformation.
5868
5869             Example of usage:
5870                 rot2d = geompy.MultiRotate2D(prism, vect, 60, 4, 50, 5)
5871             """
5872             # Example: see GEOM_TestAll.py
5873             theAngle, theNbTimes1, theStep, theNbTimes2, Parameters = ParseParameters(theAngle, theNbTimes1, theStep, theNbTimes2)
5874             anObj = self.TrsfOp.MultiRotate2D(theObject, theAxis, theAngle, theNbTimes1, theStep, theNbTimes2)
5875             RaiseIfFailed("MultiRotate2D", self.TrsfOp)
5876             anObj.SetParameters(Parameters)
5877             return anObj
5878
5879         ## The same, as MultiRotate1D(), but axis is given by direction and point
5880         #
5881         #  @ref swig_MakeMultiRotation "Example"
5882         def MakeMultiRotation1D(self,aShape,aDir,aPoint,aNbTimes):
5883             """
5884             The same, as geompy.MultiRotate1D, but axis is given by direction and point
5885
5886             Example of usage:
5887                 pz = geompy.MakeVertex(0, 0, 100)
5888                 vy = geompy.MakeVectorDXDYDZ(0, 100, 0)
5889                 MultiRot1D = geompy.MakeMultiRotation1D(prism, vy, pz, 6)
5890             """
5891             # Example: see GEOM_TestOthers.py
5892             aVec = self.MakeLine(aPoint,aDir)
5893             anObj = self.MultiRotate1D(aShape,aVec,aNbTimes)
5894             return anObj
5895
5896         ## The same, as MultiRotate2D(), but axis is given by direction and point
5897         #
5898         #  @ref swig_MakeMultiRotation "Example"
5899         def MakeMultiRotation2D(self,aShape,aDir,aPoint,anAngle,nbtimes1,aStep,nbtimes2):
5900             """
5901             The same, as MultiRotate2D(), but axis is given by direction and point
5902
5903             Example of usage:
5904                 pz = geompy.MakeVertex(0, 0, 100)
5905                 vy = geompy.MakeVectorDXDYDZ(0, 100, 0)
5906                 MultiRot2D = geompy.MakeMultiRotation2D(f12, vy, pz, 45, 6, 30, 3)
5907             """
5908             # Example: see GEOM_TestOthers.py
5909             aVec = self.MakeLine(aPoint,aDir)
5910             anObj = self.MultiRotate2D(aShape,aVec,anAngle,nbtimes1,aStep,nbtimes2)
5911             return anObj
5912
5913         # end of l3_transform
5914         ## @}
5915
5916         ## @addtogroup l3_local
5917         ## @{
5918
5919         ## Perform a fillet on all edges of the given shape.
5920         #  @param theShape Shape, to perform fillet on.
5921         #  @param theR Fillet radius.
5922         #  @return New GEOM.GEOM_Object, containing the result shape.
5923         #
5924         #  @ref tui_fillet "Example 1"
5925         #  \n @ref swig_MakeFilletAll "Example 2"
5926         def MakeFilletAll(self,theShape, theR):
5927             """
5928             Perform a fillet on all edges of the given shape.
5929
5930             Parameters:
5931                 theShape Shape, to perform fillet on.
5932                 theR Fillet radius.
5933
5934             Returns:
5935                 New GEOM.GEOM_Object, containing the result shape.
5936
5937             Example of usage:
5938                filletall = geompy.MakeFilletAll(prism, 10.)
5939             """
5940             # Example: see GEOM_TestOthers.py
5941             theR,Parameters = ParseParameters(theR)
5942             anObj = self.LocalOp.MakeFilletAll(theShape, theR)
5943             RaiseIfFailed("MakeFilletAll", self.LocalOp)
5944             anObj.SetParameters(Parameters)
5945             return anObj
5946
5947         ## Perform a fillet on the specified edges/faces of the given shape
5948         #  @param theShape Shape, to perform fillet on.
5949         #  @param theR Fillet radius.
5950         #  @param theShapeType Type of shapes in <VAR>theListShapes</VAR> (see ShapeType())
5951         #  @param theListShapes Global indices of edges/faces to perform fillet on.
5952         #    \note Global index of sub-shape can be obtained, using method GetSubShapeID().
5953         #  @return New GEOM.GEOM_Object, containing the result shape.
5954         #
5955         #  @ref tui_fillet "Example"
5956         def MakeFillet(self,theShape, theR, theShapeType, theListShapes):
5957             """
5958             Perform a fillet on the specified edges/faces of the given shape
5959
5960             Parameters:
5961                 theShape Shape, to perform fillet on.
5962                 theR Fillet radius.
5963                 theShapeType Type of shapes in theListShapes (see geompy.ShapeTypes)
5964                 theListShapes Global indices of edges/faces to perform fillet on.
5965
5966             Note:
5967                 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
5968
5969             Returns:
5970                 New GEOM.GEOM_Object, containing the result shape.
5971
5972             Example of usage:
5973                 # get the list of IDs (IDList) for the fillet
5974                 prism_edges = geompy.SubShapeAllSortedCentres(prism, geompy.ShapeType["EDGE"])
5975                 IDlist_e = []
5976                 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[0]))
5977                 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[1]))
5978                 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[2]))
5979                 # make a fillet on the specified edges of the given shape
5980                 fillet = geompy.MakeFillet(prism, 10., geompy.ShapeType["EDGE"], IDlist_e)
5981             """
5982             # Example: see GEOM_TestAll.py
5983             theR,Parameters = ParseParameters(theR)
5984             anObj = None
5985             if theShapeType == ShapeType["EDGE"]:
5986                 anObj = self.LocalOp.MakeFilletEdges(theShape, theR, theListShapes)
5987                 RaiseIfFailed("MakeFilletEdges", self.LocalOp)
5988             else:
5989                 anObj = self.LocalOp.MakeFilletFaces(theShape, theR, theListShapes)
5990                 RaiseIfFailed("MakeFilletFaces", self.LocalOp)
5991             anObj.SetParameters(Parameters)
5992             return anObj
5993
5994         ## The same that MakeFillet() but with two Fillet Radius R1 and R2
5995         def MakeFilletR1R2(self, theShape, theR1, theR2, theShapeType, theListShapes):
5996             """
5997             The same that geompy.MakeFillet but with two Fillet Radius R1 and R2
5998
5999             Example of usage:
6000                 # get the list of IDs (IDList) for the fillet
6001                 prism_edges = geompy.SubShapeAllSortedCentres(prism, geompy.ShapeType["EDGE"])
6002                 IDlist_e = []
6003                 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[0]))
6004                 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[1]))
6005                 IDlist_e.append(geompy.GetSubShapeID(prism, prism_edges[2]))
6006                 # make a fillet on the specified edges of the given shape
6007                 fillet = geompy.MakeFillet(prism, 10., 15., geompy.ShapeType["EDGE"], IDlist_e)
6008             """
6009             theR1,theR2,Parameters = ParseParameters(theR1,theR2)
6010             anObj = None
6011             if theShapeType == ShapeType["EDGE"]:
6012                 anObj = self.LocalOp.MakeFilletEdgesR1R2(theShape, theR1, theR2, theListShapes)
6013                 RaiseIfFailed("MakeFilletEdgesR1R2", self.LocalOp)
6014             else:
6015                 anObj = self.LocalOp.MakeFilletFacesR1R2(theShape, theR1, theR2, theListShapes)
6016                 RaiseIfFailed("MakeFilletFacesR1R2", self.LocalOp)
6017             anObj.SetParameters(Parameters)
6018             return anObj
6019
6020         ## Perform a fillet on the specified edges of the given shape
6021         #  @param theShape  Wire Shape to perform fillet on.
6022         #  @param theR  Fillet radius.
6023         #  @param theListOfVertexes Global indices of vertexes to perform fillet on.
6024         #    \note Global index of sub-shape can be obtained, using method GetSubShapeID()
6025         #    \note The list of vertices could be empty,
6026         #          in this case fillet will done done at all vertices in wire
6027         #  @param doIgnoreSecantVertices If FALSE, fillet radius is always limited
6028         #         by the length of the edges, nearest to the fillet vertex.
6029         #         But sometimes the next edge is C1 continuous with the one, nearest to
6030         #         the fillet point, and such two (or more) edges can be united to allow
6031         #         bigger radius. Set this flag to TRUE to allow collinear edges union,
6032         #         thus ignoring the secant vertex (vertices).
6033         #  @return New GEOM.GEOM_Object, containing the result shape.
6034         #
6035         #  @ref tui_fillet2d "Example"
6036         def MakeFillet1D(self,theShape, theR, theListOfVertexes, doIgnoreSecantVertices = True):
6037             """
6038             Perform a fillet on the specified edges of the given shape
6039
6040             Parameters:
6041                 theShape  Wire Shape to perform fillet on.
6042                 theR  Fillet radius.
6043                 theListOfVertexes Global indices of vertexes to perform fillet on.
6044                 doIgnoreSecantVertices If FALSE, fillet radius is always limited
6045                     by the length of the edges, nearest to the fillet vertex.
6046                     But sometimes the next edge is C1 continuous with the one, nearest to
6047                     the fillet point, and such two (or more) edges can be united to allow
6048                     bigger radius. Set this flag to TRUE to allow collinear edges union,
6049                     thus ignoring the secant vertex (vertices).
6050             Note:
6051                 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
6052
6053                 The list of vertices could be empty,in this case fillet will done done at all vertices in wire
6054
6055             Returns:
6056                 New GEOM.GEOM_Object, containing the result shape.
6057
6058             Example of usage:
6059                 # create wire
6060                 Wire_1 = geompy.MakeWire([Edge_12, Edge_7, Edge_11, Edge_6, Edge_1,Edge_4])
6061                 # make fillet at given wire vertices with giver radius
6062                 Fillet_1D_1 = geompy.MakeFillet1D(Wire_1, 55, [3, 4, 6, 8, 10])
6063             """
6064             # Example: see GEOM_TestAll.py
6065             theR,doIgnoreSecantVertices,Parameters = ParseParameters(theR,doIgnoreSecantVertices)
6066             anObj = self.LocalOp.MakeFillet1D(theShape, theR, theListOfVertexes, doIgnoreSecantVertices)
6067             RaiseIfFailed("MakeFillet1D", self.LocalOp)
6068             anObj.SetParameters(Parameters)
6069             return anObj
6070
6071         ## Perform a fillet at the specified vertices of the given face/shell.
6072         #  @param theShape Face or Shell shape to perform fillet on.
6073         #  @param theR Fillet radius.
6074         #  @param theListOfVertexes Global indices of vertexes to perform fillet on.
6075         #    \note Global index of sub-shape can be obtained, using method GetSubShapeID().
6076         #  @return New GEOM.GEOM_Object, containing the result shape.
6077         #
6078         #  @ref tui_fillet2d "Example"
6079         def MakeFillet2D(self, theShape, theR, theListOfVertexes):
6080             """
6081             Perform a fillet at the specified vertices of the given face/shell.
6082
6083             Parameters:
6084                 theShape  Face or Shell shape to perform fillet on.
6085                 theR  Fillet radius.
6086                 theListOfVertexes Global indices of vertexes to perform fillet on.
6087             Note:
6088                 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
6089
6090             Returns:
6091                 New GEOM.GEOM_Object, containing the result shape.
6092
6093             Example of usage:
6094                 face = geompy.MakeFaceHW(100, 100, 1)
6095                 fillet2d = geompy.MakeFillet2D(face, 30, [7, 9])
6096             """
6097             # Example: see GEOM_TestAll.py
6098             theR,Parameters = ParseParameters(theR)
6099             anObj = self.LocalOp.MakeFillet2D(theShape, theR, theListOfVertexes)
6100             RaiseIfFailed("MakeFillet2D", self.LocalOp)
6101             anObj.SetParameters(Parameters)
6102             return anObj
6103
6104         ## Perform a symmetric chamfer on all edges of the given shape.
6105         #  @param theShape Shape, to perform chamfer on.
6106         #  @param theD Chamfer size along each face.
6107         #  @return New GEOM.GEOM_Object, containing the result shape.
6108         #
6109         #  @ref tui_chamfer "Example 1"
6110         #  \n @ref swig_MakeChamferAll "Example 2"
6111         def MakeChamferAll(self,theShape, theD):
6112             """
6113             Perform a symmetric chamfer on all edges of the given shape.
6114
6115             Parameters:
6116                 theShape Shape, to perform chamfer on.
6117                 theD Chamfer size along each face.
6118
6119             Returns:
6120                 New GEOM.GEOM_Object, containing the result shape.
6121
6122             Example of usage:
6123                 chamfer_all = geompy.MakeChamferAll(prism, 10.)
6124             """
6125             # Example: see GEOM_TestOthers.py
6126             theD,Parameters = ParseParameters(theD)
6127             anObj = self.LocalOp.MakeChamferAll(theShape, theD)
6128             RaiseIfFailed("MakeChamferAll", self.LocalOp)
6129             anObj.SetParameters(Parameters)
6130             return anObj
6131
6132         ## Perform a chamfer on edges, common to the specified faces,
6133         #  with distance D1 on the Face1
6134         #  @param theShape Shape, to perform chamfer on.
6135         #  @param theD1 Chamfer size along \a theFace1.
6136         #  @param theD2 Chamfer size along \a theFace2.
6137         #  @param theFace1,theFace2 Global indices of two faces of \a theShape.
6138         #    \note Global index of sub-shape can be obtained, using method GetSubShapeID().
6139         #  @return New GEOM.GEOM_Object, containing the result shape.
6140         #
6141         #  @ref tui_chamfer "Example"
6142         def MakeChamferEdge(self,theShape, theD1, theD2, theFace1, theFace2):
6143             """
6144             Perform a chamfer on edges, common to the specified faces,
6145             with distance D1 on the Face1
6146
6147             Parameters:
6148                 theShape Shape, to perform chamfer on.
6149                 theD1 Chamfer size along theFace1.
6150                 theD2 Chamfer size along theFace2.
6151                 theFace1,theFace2 Global indices of two faces of theShape.
6152
6153             Note:
6154                 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
6155
6156             Returns:
6157                 New GEOM.GEOM_Object, containing the result shape.
6158
6159             Example of usage:
6160                 prism_faces = geompy.SubShapeAllSortedCentres(prism, geompy.ShapeType["FACE"])
6161                 f_ind_1 = geompy.GetSubShapeID(prism, prism_faces[0])
6162                 f_ind_2 = geompy.GetSubShapeID(prism, prism_faces[1])
6163                 chamfer_e = geompy.MakeChamferEdge(prism, 10., 10., f_ind_1, f_ind_2)
6164             """
6165             # Example: see GEOM_TestAll.py
6166             theD1,theD2,Parameters = ParseParameters(theD1,theD2)
6167             anObj = self.LocalOp.MakeChamferEdge(theShape, theD1, theD2, theFace1, theFace2)
6168             RaiseIfFailed("MakeChamferEdge", self.LocalOp)
6169             anObj.SetParameters(Parameters)
6170             return anObj
6171
6172         ## Perform a chamfer on edges
6173         #  @param theShape Shape, to perform chamfer on.
6174         #  @param theD Chamfer length
6175         #  @param theAngle Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
6176         #  @param theFace1,theFace2 Global indices of two faces of \a theShape.
6177         #    \note Global index of sub-shape can be obtained, using method GetSubShapeID().
6178         #  @return New GEOM.GEOM_Object, containing the result shape.
6179         def MakeChamferEdgeAD(self, theShape, theD, theAngle, theFace1, theFace2):
6180             """
6181             Perform a chamfer on edges
6182
6183             Parameters:
6184                 theShape Shape, to perform chamfer on.
6185                 theD1 Chamfer size along theFace1.
6186                 theAngle Angle of chamfer (angle in radians or a name of variable which defines angle in degrees).
6187                 theFace1,theFace2 Global indices of two faces of theShape.
6188
6189             Note:
6190                 Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
6191
6192             Returns:
6193                 New GEOM.GEOM_Object, containing the result shape.
6194
6195             Example of usage:
6196                 prism_faces = geompy.SubShapeAllSortedCentres(prism, geompy.ShapeType["FACE"])
6197                 f_ind_1 = geompy.GetSubShapeID(prism, prism_faces[0])
6198                 f_ind_2 = geompy.GetSubShapeID(prism, prism_faces[1])
6199                 ang = 30
6200                 chamfer_e = geompy.MakeChamferEdge(prism, 10., ang, f_ind_1, f_ind_2)
6201             """
6202             flag = False
6203             if isinstance(theAngle,str):
6204                 flag = True
6205             theD,theAngle,Parameters = ParseParameters(theD,theAngle)
6206             if flag:
6207                 theAngle = theAngle*math.pi/180.0
6208             anObj = self.LocalOp.MakeChamferEdgeAD(theShape, theD, theAngle, theFace1, theFace2)
6209             RaiseIfFailed("MakeChamferEdgeAD", self.LocalOp)
6210             anObj.SetParameters(Parameters)
6211             return anObj
6212
6213         ## Perform a chamfer on all edges of the specified faces,
6214         #  with distance D1 on the first specified face (if several for one edge)
6215         #  @param theShape Shape, to perform chamfer on.
6216         #  @param theD1 Chamfer size along face from \a theFaces. If both faces,
6217         #               connected to the edge, are in \a theFaces, \a theD1
6218         #               will be get along face, which is nearer to \a theFaces beginning.
6219         #  @param theD2 Chamfer size along another of two faces, connected to the edge.
6220         #  @param theFaces Sequence of global indices of faces of \a theShape.
6221         #    \note Global index of sub-shape can be obtained, using method GetSubShapeID().
6222         #  @return New GEOM.GEOM_Object, containing the result shape.
6223         #
6224         #  @ref tui_chamfer "Example"
6225         def MakeChamferFaces(self,theShape, theD1, theD2, theFaces):
6226             """
6227             Perform a chamfer on all edges of the specified faces,
6228             with distance D1 on the first specified face (if several for one edge)
6229
6230             Parameters:
6231                 theShape Shape, to perform chamfer on.
6232                 theD1 Chamfer size along face from  theFaces. If both faces,
6233                       connected to the edge, are in theFaces, theD1
6234                       will be get along face, which is nearer to theFaces beginning.
6235                 theD2 Chamfer size along another of two faces, connected to the edge.
6236                 theFaces Sequence of global indices of faces of theShape.
6237
6238
6239             Note: Global index of sub-shape can be obtained, using method geompy.GetSubShapeID().
6240
6241             Returns:
6242                 New GEOM.GEOM_Object, containing the result shape.
6243             """
6244             # Example: see GEOM_TestAll.py
6245             theD1,theD2,Parameters = ParseParameters(theD1,theD2)
6246             anObj = self.LocalOp.MakeChamferFaces(theShape, theD1, theD2, theFaces)
6247             RaiseIfFailed("MakeChamferFaces", self.LocalOp)
6248             anObj.SetParameters(Parameters)
6249             return anObj
6250
6251         ## The Same that MakeChamferFaces() but with params theD is chamfer lenght and
6252         #  theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
6253         #
6254         #  @ref swig_FilletChamfer "Example"
6255         def MakeChamferFacesAD(self, theShape, theD, theAngle, theFaces):
6256             """
6257             The Same that geompy.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)
6259             """
6260             flag = False
6261             if isinstance(theAngle,str):
6262                 flag = True
6263             theD,theAngle,Parameters = ParseParameters(theD,theAngle)
6264             if flag:
6265                 theAngle = theAngle*math.pi/180.0
6266             anObj = self.LocalOp.MakeChamferFacesAD(theShape, theD, theAngle, theFaces)
6267             RaiseIfFailed("MakeChamferFacesAD", self.LocalOp)
6268             anObj.SetParameters(Parameters)
6269             return anObj
6270
6271         ## Perform a chamfer on edges,
6272         #  with distance D1 on the first specified face (if several for one edge)
6273         #  @param theShape Shape, to perform chamfer on.
6274         #  @param theD1,theD2 Chamfer size
6275         #  @param theEdges Sequence of edges of \a theShape.
6276         #  @return New GEOM.GEOM_Object, containing the result shape.
6277         #
6278         #  @ref swig_FilletChamfer "Example"
6279         def MakeChamferEdges(self, theShape, theD1, theD2, theEdges):
6280             """
6281             Perform a chamfer on edges,
6282             with distance D1 on the first specified face (if several for one edge)
6283
6284             Parameters:
6285                 theShape Shape, to perform chamfer on.
6286                 theD1,theD2 Chamfer size
6287                 theEdges Sequence of edges of theShape.
6288
6289             Returns:
6290                 New GEOM.GEOM_Object, containing the result shape.
6291             """
6292             theD1,theD2,Parameters = ParseParameters(theD1,theD2)
6293             anObj = self.LocalOp.MakeChamferEdges(theShape, theD1, theD2, theEdges)
6294             RaiseIfFailed("MakeChamferEdges", self.LocalOp)
6295             anObj.SetParameters(Parameters)
6296             return anObj
6297
6298         ## The Same that MakeChamferEdges() but with params theD is chamfer lenght and
6299         #  theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
6300         def MakeChamferEdgesAD(self, theShape, theD, theAngle, theEdges):
6301             """
6302             The Same that geompy.MakeChamferEdges but with params theD is chamfer lenght and
6303             theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
6304             """
6305             flag = False
6306             if isinstance(theAngle,str):
6307                 flag = True
6308             theD,theAngle,Parameters = ParseParameters(theD,theAngle)
6309             if flag:
6310                 theAngle = theAngle*math.pi/180.0
6311             anObj = self.LocalOp.MakeChamferEdgesAD(theShape, theD, theAngle, theEdges)
6312             RaiseIfFailed("MakeChamferEdgesAD", self.LocalOp)
6313             anObj.SetParameters(Parameters)
6314             return anObj
6315
6316         ## /sa MakeChamferEdge() and MakeChamferFaces()
6317         #
6318         #  @ref swig_MakeChamfer "Example"
6319         def MakeChamfer(self,aShape,d1,d2,aShapeType,ListShape):
6320             """
6321             See geompy.MakeChamferEdge() and geompy.MakeChamferFaces() functions for more information.
6322             """
6323             # Example: see GEOM_TestOthers.py
6324             anObj = None
6325             if aShapeType == ShapeType["EDGE"]:
6326                 anObj = self.MakeChamferEdge(aShape,d1,d2,ListShape[0],ListShape[1])
6327             else:
6328                 anObj = self.MakeChamferFaces(aShape,d1,d2,ListShape)
6329             return anObj
6330
6331         ## Remove material from a solid by extrusion of the base shape on the given distance.
6332         #  @param theInit Shape to remove material from. It must be a solid or
6333         #  a compound made of a single solid.
6334         #  @param theBase Closed edge or wire defining the base shape to be extruded.
6335         #  @param theH Prism dimension along the normal to theBase
6336         #  @param theAngle Draft angle in degrees.
6337         #  @return New GEOM.GEOM_Object, containing the initial shape with removed material
6338         #
6339         #  @ref tui_creation_prism "Example"
6340         def MakeExtrudedCut(self, theInit, theBase, theH, theAngle):
6341             """
6342             Add material to a solid by extrusion of the base shape on the given distance.
6343
6344             Parameters:
6345                 theInit Shape to remove material from. It must be a solid or a compound made of a single solid.
6346                 theBase Closed edge or wire defining the base shape to be extruded.
6347                 theH Prism dimension along the normal  to theBase
6348                 theAngle Draft angle in degrees.
6349
6350             Returns:
6351                 New GEOM.GEOM_Object,  containing the initial shape with removed material.
6352             """
6353             # Example: see GEOM_TestAll.py
6354             #theH,Parameters = ParseParameters(theH)
6355             anObj = self.PrimOp.MakeDraftPrism(theInit, theBase, theH, theAngle, False)
6356             RaiseIfFailed("MakeExtrudedBoss", self.PrimOp)
6357             #anObj.SetParameters(Parameters)
6358             return anObj
6359
6360         ## Add material to a solid by extrusion of the base shape on the given distance.
6361         #  @param theInit Shape to add material to. It must be a solid or
6362         #  a compound made of a single solid.
6363         #  @param theBase Closed edge or wire defining the base shape to be extruded.
6364         #  @param theH Prism dimension along the normal to theBase
6365         #  @param theAngle Draft angle in degrees.
6366         #  @return New GEOM.GEOM_Object, containing the initial shape with added material
6367         #
6368         #  @ref tui_creation_prism "Example"
6369         def MakeExtrudedBoss(self, theInit, theBase, theH, theAngle):
6370             """
6371             Add material to a solid by extrusion of the base shape on the given distance.
6372
6373             Parameters:
6374                 theInit Shape to add material to. It must be a solid or a compound made of a single solid.
6375                 theBase Closed edge or wire defining the base shape to be extruded.
6376                 theH Prism dimension along the normal  to theBase
6377                 theAngle Draft angle in degrees.
6378
6379             Returns:
6380                 New GEOM.GEOM_Object,  containing the initial shape with added material.
6381             """
6382             # Example: see GEOM_TestAll.py
6383             #theH,Parameters = ParseParameters(theH)
6384             anObj = self.PrimOp.MakeDraftPrism(theInit, theBase, theH, theAngle, True)
6385             RaiseIfFailed("MakeExtrudedBoss", self.PrimOp)
6386             #anObj.SetParameters(Parameters)
6387             return anObj
6388
6389         # end of l3_local
6390         ## @}
6391
6392         ## @addtogroup l3_basic_op
6393         ## @{
6394
6395         ## Perform an Archimde operation on the given shape with given parameters.
6396         #  The object presenting the resulting face is returned.
6397         #  @param theShape Shape to be put in water.
6398         #  @param theWeight Weight og the shape.
6399         #  @param theWaterDensity Density of the water.
6400         #  @param theMeshDeflection Deflection of the mesh, using to compute the section.
6401         #  @return New GEOM.GEOM_Object, containing a section of \a theShape
6402         #          by a plane, corresponding to water level.
6403         #
6404         #  @ref tui_archimede "Example"
6405         def Archimede(self,theShape, theWeight, theWaterDensity, theMeshDeflection):
6406             """
6407             Perform an Archimde operation on the given shape with given parameters.
6408             The object presenting the resulting face is returned.
6409
6410             Parameters:
6411                 theShape Shape to be put in water.
6412                 theWeight Weight og the shape.
6413                 theWaterDensity Density of the water.
6414                 theMeshDeflection Deflection of the mesh, using to compute the section.
6415
6416             Returns:
6417                 New GEOM.GEOM_Object, containing a section of theShape
6418                 by a plane, corresponding to water level.
6419             """
6420             # Example: see GEOM_TestAll.py
6421             theWeight,theWaterDensity,theMeshDeflection,Parameters = ParseParameters(
6422               theWeight,theWaterDensity,theMeshDeflection)
6423             anObj = self.LocalOp.MakeArchimede(theShape, theWeight, theWaterDensity, theMeshDeflection)
6424             RaiseIfFailed("MakeArchimede", self.LocalOp)
6425             anObj.SetParameters(Parameters)
6426             return anObj
6427
6428         # end of l3_basic_op
6429         ## @}
6430
6431         ## @addtogroup l2_measure
6432         ## @{
6433
6434         ## Get point coordinates
6435         #  @return [x, y, z]
6436         #
6437         #  @ref tui_measurement_tools_page "Example"
6438         def PointCoordinates(self,Point):
6439             """
6440             Get point coordinates
6441
6442             Returns:
6443                 [x, y, z]
6444             """
6445             # Example: see GEOM_TestMeasures.py
6446             aTuple = self.MeasuOp.PointCoordinates(Point)
6447             RaiseIfFailed("PointCoordinates", self.MeasuOp)
6448             return aTuple
6449
6450         ## Get summarized length of all wires,
6451         #  area of surface and volume of the given shape.
6452         #  @param theShape Shape to define properties of.
6453         #  @return [theLength, theSurfArea, theVolume]\n
6454         #  theLength:   Summarized length of all wires of the given shape.\n
6455         #  theSurfArea: Area of surface of the given shape.\n
6456         #  theVolume:   Volume of the given shape.
6457         #
6458         #  @ref tui_measurement_tools_page "Example"
6459         def BasicProperties(self,theShape):
6460             """
6461             Get summarized length of all wires,
6462             area of surface and volume of the given shape.
6463
6464             Parameters:
6465                 theShape Shape to define properties of.
6466
6467             Returns:
6468                 [theLength, theSurfArea, theVolume]
6469                  theLength:   Summarized length of all wires of the given shape.
6470                  theSurfArea: Area of surface of the given shape.
6471                  theVolume:   Volume of the given shape.
6472             """
6473             # Example: see GEOM_TestMeasures.py
6474             aTuple = self.MeasuOp.GetBasicProperties(theShape)
6475             RaiseIfFailed("GetBasicProperties", self.MeasuOp)
6476             return aTuple
6477
6478         ## Get parameters of bounding box of the given shape
6479         #  @param theShape Shape to obtain bounding box of.
6480         #  @return [Xmin,Xmax, Ymin,Ymax, Zmin,Zmax]
6481         #  Xmin,Xmax: Limits of shape along OX axis.
6482         #  Ymin,Ymax: Limits of shape along OY axis.
6483         #  Zmin,Zmax: Limits of shape along OZ axis.
6484         #
6485         #  @ref tui_measurement_tools_page "Example"
6486         def BoundingBox(self,theShape):
6487             """
6488             Get parameters of bounding box of the given shape
6489
6490             Parameters:
6491                 theShape Shape to obtain bounding box of.
6492
6493             Returns:
6494                 [Xmin,Xmax, Ymin,Ymax, Zmin,Zmax]
6495                  Xmin,Xmax: Limits of shape along OX axis.
6496                  Ymin,Ymax: Limits of shape along OY axis.
6497                  Zmin,Zmax: Limits of shape along OZ axis.
6498             """
6499             # Example: see GEOM_TestMeasures.py
6500             aTuple = self.MeasuOp.GetBoundingBox(theShape)
6501             RaiseIfFailed("GetBoundingBox", self.MeasuOp)
6502             return aTuple
6503
6504         ## Get inertia matrix and moments of inertia of theShape.
6505         #  @param theShape Shape to calculate inertia of.
6506         #  @return [I11,I12,I13, I21,I22,I23, I31,I32,I33, Ix,Iy,Iz]
6507         #  I(1-3)(1-3): Components of the inertia matrix of the given shape.
6508         #  Ix,Iy,Iz:    Moments of inertia of the given shape.
6509         #
6510         #  @ref tui_measurement_tools_page "Example"
6511         def Inertia(self,theShape):
6512             """
6513             Get inertia matrix and moments of inertia of theShape.
6514
6515             Parameters:
6516                 theShape Shape to calculate inertia of.
6517
6518             Returns:
6519                 [I11,I12,I13, I21,I22,I23, I31,I32,I33, Ix,Iy,Iz]
6520                  I(1-3)(1-3): Components of the inertia matrix of the given shape.
6521                  Ix,Iy,Iz:    Moments of inertia of the given shape.
6522             """
6523             # Example: see GEOM_TestMeasures.py
6524             aTuple = self.MeasuOp.GetInertia(theShape)
6525             RaiseIfFailed("GetInertia", self.MeasuOp)
6526             return aTuple
6527
6528         ## Get if coords are included in the shape (ST_IN or ST_ON)
6529         #  @param theShape Shape
6530         #  @param coords list of points coordinates [x1, y1, z1, x2, y2, z2, ...]
6531         #  @param tolerance to be used (default is 1.0e-7)
6532         #  @return list_of_boolean = [res1, res2, ...]
6533         def AreCoordsInside(self, theShape, coords, tolerance=1.e-7):
6534             """
6535             Get if coords are included in the shape (ST_IN or ST_ON)
6536
6537             Parameters:
6538                 theShape Shape
6539                 coords list of points coordinates [x1, y1, z1, x2, y2, z2, ...]
6540                 tolerance to be used (default is 1.0e-7)
6541
6542             Returns:
6543                 list_of_boolean = [res1, res2, ...]
6544             """
6545             return self.MeasuOp.AreCoordsInside(theShape, coords, tolerance)
6546
6547         ## Get minimal distance between the given shapes.
6548         #  @param theShape1,theShape2 Shapes to find minimal distance between.
6549         #  @return Value of the minimal distance between the given shapes.
6550         #
6551         #  @ref tui_measurement_tools_page "Example"
6552         def MinDistance(self, theShape1, theShape2):
6553             """
6554             Get minimal distance between the given shapes.
6555
6556             Parameters:
6557                 theShape1,theShape2 Shapes to find minimal distance between.
6558
6559             Returns:
6560                 Value of the minimal distance between the given shapes.
6561             """
6562             # Example: see GEOM_TestMeasures.py
6563             aTuple = self.MeasuOp.GetMinDistance(theShape1, theShape2)
6564             RaiseIfFailed("GetMinDistance", self.MeasuOp)
6565             return aTuple[0]
6566
6567         ## Get minimal distance between the given shapes.
6568         #  @param theShape1,theShape2 Shapes to find minimal distance between.
6569         #  @return Value of the minimal distance between the given shapes.
6570         #
6571         #  @ref swig_all_measure "Example"
6572         def MinDistanceComponents(self, theShape1, theShape2):
6573             """
6574             Get minimal distance between the given shapes.
6575
6576             Parameters:
6577                 theShape1,theShape2 Shapes to find minimal distance between.
6578
6579             Returns:
6580                 Value of the minimal distance between the given shapes.
6581             """
6582             # Example: see GEOM_TestMeasures.py
6583             aTuple = self.MeasuOp.GetMinDistance(theShape1, theShape2)
6584             RaiseIfFailed("GetMinDistance", self.MeasuOp)
6585             aRes = [aTuple[0], aTuple[4] - aTuple[1], aTuple[5] - aTuple[2], aTuple[6] - aTuple[3]]
6586             return aRes
6587
6588         ## Get angle between the given shapes in degrees.
6589         #  @param theShape1,theShape2 Lines or linear edges to find angle between.
6590         #  @note If both arguments are vectors, the angle is computed in accordance
6591         #        with their orientations, otherwise the minimum angle is computed.
6592         #  @return Value of the angle between the given shapes in degrees.
6593         #
6594         #  @ref tui_measurement_tools_page "Example"
6595         def GetAngle(self, theShape1, theShape2):
6596             """
6597             Get angle between the given shapes in degrees.
6598
6599             Parameters:
6600                 theShape1,theShape2 Lines or linear edges to find angle between.
6601
6602             Note:
6603                 If both arguments are vectors, the angle is computed in accordance
6604                 with their orientations, otherwise the minimum angle is computed.
6605
6606             Returns:
6607                 Value of the angle between the given shapes in degrees.
6608             """
6609             # Example: see GEOM_TestMeasures.py
6610             anAngle = self.MeasuOp.GetAngle(theShape1, theShape2)
6611             RaiseIfFailed("GetAngle", self.MeasuOp)
6612             return anAngle
6613
6614         ## Get angle between the given shapes in radians.
6615         #  @param theShape1,theShape2 Lines or linear edges to find angle between.
6616         #  @note If both arguments are vectors, the angle is computed in accordance
6617         #        with their orientations, otherwise the minimum angle is computed.
6618         #  @return Value of the angle between the given shapes in radians.
6619         #
6620         #  @ref tui_measurement_tools_page "Example"
6621         def GetAngleRadians(self, theShape1, theShape2):
6622             """
6623             Get angle between the given shapes in radians.
6624
6625             Parameters:
6626                 theShape1,theShape2 Lines or linear edges to find angle between.
6627
6628
6629             Note:
6630                 If both arguments are vectors, the angle is computed in accordance
6631                 with their orientations, otherwise the minimum angle is computed.
6632
6633             Returns:
6634                 Value of the angle between the given shapes in radians.
6635             """
6636             # Example: see GEOM_TestMeasures.py
6637             anAngle = self.MeasuOp.GetAngle(theShape1, theShape2)*math.pi/180.
6638             RaiseIfFailed("GetAngle", self.MeasuOp)
6639             return anAngle
6640
6641         ## @name Curve Curvature Measurement
6642         #  Methods for receiving radius of curvature of curves
6643         #  in the given point
6644         ## @{
6645
6646         ## Measure curvature of a curve at a point, set by parameter.
6647         #  @param theCurve a curve.
6648         #  @param theParam parameter.
6649         #  @return radius of curvature of \a theCurve.
6650         #
6651         #  @ref swig_todo "Example"
6652         def CurveCurvatureByParam(self, theCurve, theParam):
6653             """
6654             Measure curvature of a curve at a point, set by parameter.
6655
6656             Parameters:
6657                 theCurve a curve.
6658                 theParam parameter.
6659
6660             Returns:
6661                 radius of curvature of theCurve.
6662             """
6663             # Example: see GEOM_TestMeasures.py
6664             aCurv = self.MeasuOp.CurveCurvatureByParam(theCurve,theParam)
6665             RaiseIfFailed("CurveCurvatureByParam", self.MeasuOp)
6666             return aCurv
6667
6668         ## Measure curvature of a curve at a point.
6669         #  @param theCurve a curve.
6670         #  @param thePoint given point.
6671         #  @return radius of curvature of \a theCurve.
6672         #
6673         #  @ref swig_todo "Example"
6674         def CurveCurvatureByPoint(self, theCurve, thePoint):
6675             """
6676             Measure curvature of a curve at a point.
6677
6678             Parameters:
6679                 theCurve a curve.
6680                 thePoint given point.
6681
6682             Returns:
6683                 radius of curvature of theCurve.
6684             """
6685             aCurv = self.MeasuOp.CurveCurvatureByPoint(theCurve,thePoint)
6686             RaiseIfFailed("CurveCurvatureByPoint", self.MeasuOp)
6687             return aCurv
6688         ## @}
6689
6690         ## @name Surface Curvature Measurement
6691         #  Methods for receiving max and min radius of curvature of surfaces
6692         #  in the given point
6693         ## @{
6694
6695         ## Measure max radius of curvature of surface.
6696         #  @param theSurf the given surface.
6697         #  @param theUParam Value of U-parameter on the referenced surface.
6698         #  @param theVParam Value of V-parameter on the referenced surface.
6699         #  @return max radius of curvature of theSurf.
6700         #
6701         ## @ref swig_todo "Example"
6702         def MaxSurfaceCurvatureByParam(self, theSurf, theUParam, theVParam):
6703             """
6704             Measure max radius of curvature of surface.
6705
6706             Parameters:
6707                 theSurf the given surface.
6708                 theUParam Value of U-parameter on the referenced surface.
6709                 theVParam Value of V-parameter on the referenced surface.
6710
6711             Returns:
6712                 max radius of curvature of theSurf.
6713             """
6714             # Example: see GEOM_TestMeasures.py
6715             aSurf = self.MeasuOp.MaxSurfaceCurvatureByParam(theSurf,theUParam,theVParam)
6716             RaiseIfFailed("MaxSurfaceCurvatureByParam", self.MeasuOp)
6717             return aSurf
6718
6719         ## Measure max radius of curvature of surface in the given point
6720         #  @param theSurf the given surface.
6721         #  @param thePoint given point.
6722         #  @return max radius of curvature of theSurf.
6723         #
6724         ## @ref swig_todo "Example"
6725         def MaxSurfaceCurvatureByPoint(self, theSurf, thePoint):
6726             """
6727             Measure max radius of curvature of surface in the given point.
6728
6729             Parameters:
6730                 theSurf the given surface.
6731                 thePoint given point.
6732
6733             Returns:
6734                 max radius of curvature of theSurf.
6735             """
6736             aSurf = self.MeasuOp.MaxSurfaceCurvatureByPoint(theSurf,thePoint)
6737             RaiseIfFailed("MaxSurfaceCurvatureByPoint", self.MeasuOp)
6738             return aSurf
6739
6740         ## Measure min radius of curvature of surface.
6741         #  @param theSurf the given surface.
6742         #  @param theUParam Value of U-parameter on the referenced surface.
6743         #  @param theVParam Value of V-parameter on the referenced surface.
6744         #  @return min radius of curvature of theSurf.
6745         #
6746         ## @ref swig_todo "Example"
6747         def MinSurfaceCurvatureByParam(self, theSurf, theUParam, theVParam):
6748             """
6749             Measure min radius of curvature of surface.
6750
6751             Parameters:
6752                 theSurf the given surface.
6753                 theUParam Value of U-parameter on the referenced surface.
6754                 theVParam Value of V-parameter on the referenced surface.
6755
6756             Returns:
6757                 Min radius of curvature of theSurf.
6758             """
6759             aSurf = self.MeasuOp.MinSurfaceCurvatureByParam(theSurf,theUParam,theVParam)
6760             RaiseIfFailed("MinSurfaceCurvatureByParam", self.MeasuOp)
6761             return aSurf
6762
6763         ## Measure min radius of curvature of surface in the given point
6764         #  @param theSurf the given surface.
6765         #  @param thePoint given point.
6766         #  @return min radius of curvature of theSurf.
6767         #
6768         ## @ref swig_todo "Example"
6769         def MinSurfaceCurvatureByPoint(self, theSurf, thePoint):
6770             """
6771             Measure min radius of curvature of surface in the given point.
6772
6773             Parameters:
6774                 theSurf the given surface.
6775                 thePoint given point.
6776
6777             Returns:
6778                 Min radius of curvature of theSurf.
6779             """
6780             aSurf = self.MeasuOp.MinSurfaceCurvatureByPoint(theSurf,thePoint)
6781             RaiseIfFailed("MinSurfaceCurvatureByPoint", self.MeasuOp)
6782             return aSurf
6783         ## @}
6784
6785         ## Get min and max tolerances of sub-shapes of theShape
6786         #  @param theShape Shape, to get tolerances of.
6787         #  @return [FaceMin,FaceMax, EdgeMin,EdgeMax, VertMin,VertMax]\n
6788         #  FaceMin,FaceMax: Min and max tolerances of the faces.\n
6789         #  EdgeMin,EdgeMax: Min and max tolerances of the edges.\n
6790         #  VertMin,VertMax: Min and max tolerances of the vertices.
6791         #
6792         #  @ref tui_measurement_tools_page "Example"
6793         def Tolerance(self,theShape):
6794             """
6795             Get min and max tolerances of sub-shapes of theShape
6796
6797             Parameters:
6798                 theShape Shape, to get tolerances of.
6799
6800             Returns:
6801                 [FaceMin,FaceMax, EdgeMin,EdgeMax, VertMin,VertMax]
6802                  FaceMin,FaceMax: Min and max tolerances of the faces.
6803                  EdgeMin,EdgeMax: Min and max tolerances of the edges.
6804                  VertMin,VertMax: Min and max tolerances of the vertices.
6805             """
6806             # Example: see GEOM_TestMeasures.py
6807             aTuple = self.MeasuOp.GetTolerance(theShape)
6808             RaiseIfFailed("GetTolerance", self.MeasuOp)
6809             return aTuple
6810
6811         ## Obtain description of the given shape (number of sub-shapes of each type)
6812         #  @param theShape Shape to be described.
6813         #  @return Description of the given shape.
6814         #
6815         #  @ref tui_measurement_tools_page "Example"
6816         def WhatIs(self,theShape):
6817             """
6818             Obtain description of the given shape (number of sub-shapes of each type)
6819
6820             Parameters:
6821                 theShape Shape to be described.
6822
6823             Returns:
6824                 Description of the given shape.
6825             """
6826             # Example: see GEOM_TestMeasures.py
6827             aDescr = self.MeasuOp.WhatIs(theShape)
6828             RaiseIfFailed("WhatIs", self.MeasuOp)
6829             return aDescr
6830
6831         ## Obtain quantity of shapes of the given type in \a theShape.
6832         #  If \a theShape is of type \a theType, it is also counted.
6833         #  @param theShape Shape to be described.
6834         #  @param theType the given ShapeType().
6835         #  @return Quantity of shapes of type \a theType in \a theShape.
6836         #
6837         #  @ref tui_measurement_tools_page "Example"
6838         def NbShapes (self, theShape, theType):
6839             """
6840             Obtain quantity of shapes of the given type in theShape.
6841             If theShape is of type theType, it is also counted.
6842
6843             Parameters:
6844                 theShape Shape to be described.
6845                 theType the given geompy.ShapeType
6846
6847             Returns:
6848                 Quantity of shapes of type theType in theShape.
6849             """
6850             # Example: see GEOM_TestMeasures.py
6851             listSh = self.SubShapeAllIDs(theShape, theType)
6852             Nb = len(listSh)
6853             t       = EnumToLong(theShape.GetShapeType())
6854             theType = EnumToLong(theType)
6855             if t == theType:
6856                 Nb = Nb + 1
6857                 pass
6858             return Nb
6859
6860         ## Obtain quantity of shapes of each type in \a theShape.
6861         #  The \a theShape is also counted.
6862         #  @param theShape Shape to be described.
6863         #  @return Dictionary of ShapeType() with bound quantities of shapes.
6864         #
6865         #  @ref tui_measurement_tools_page "Example"
6866         def ShapeInfo (self, theShape):
6867             """
6868             Obtain quantity of shapes of each type in theShape.
6869             The theShape is also counted.
6870
6871             Parameters:
6872                 theShape Shape to be described.
6873
6874             Returns:
6875                 Dictionary of geompy.ShapeType with bound quantities of shapes.
6876             """
6877             # Example: see GEOM_TestMeasures.py
6878             aDict = {}
6879             for typeSh in ShapeType:
6880                 if typeSh in ( "AUTO", "SHAPE" ): continue
6881                 listSh = self.SubShapeAllIDs(theShape, ShapeType[typeSh])
6882                 Nb = len(listSh)
6883                 if EnumToLong(theShape.GetShapeType()) == ShapeType[typeSh]:
6884                     Nb = Nb + 1
6885                     pass
6886                 aDict[typeSh] = Nb
6887                 pass
6888             return aDict
6889
6890         ## Get a point, situated at the centre of mass of theShape.
6891         #  @param theShape Shape to define centre of mass of.
6892         #  @return New GEOM.GEOM_Object, containing the created point.
6893         #
6894         #  @ref tui_measurement_tools_page "Example"
6895         def MakeCDG(self,theShape):
6896             """
6897             Get a point, situated at the centre of mass of theShape.
6898
6899             Parameters:
6900                 theShape Shape to define centre of mass of.
6901
6902             Returns:
6903                 New GEOM.GEOM_Object, containing the created point.
6904             """
6905             # Example: see GEOM_TestMeasures.py
6906             anObj = self.MeasuOp.GetCentreOfMass(theShape)
6907             RaiseIfFailed("GetCentreOfMass", self.MeasuOp)
6908             return anObj
6909
6910         ## Get a vertex sub-shape by index depended with orientation.
6911         #  @param theShape Shape to find sub-shape.
6912         #  @param theIndex Index to find vertex by this index (starting from zero)
6913         #  @return New GEOM.GEOM_Object, containing the created vertex.
6914         #
6915         #  @ref tui_measurement_tools_page "Example"
6916         def GetVertexByIndex(self,theShape, theIndex):
6917             """
6918             Get a vertex sub-shape by index depended with orientation.
6919
6920             Parameters:
6921                 theShape Shape to find sub-shape.
6922                 theIndex Index to find vertex by this index (starting from zero)
6923
6924             Returns:
6925                 New GEOM.GEOM_Object, containing the created vertex.
6926             """
6927             # Example: see GEOM_TestMeasures.py
6928             anObj = self.MeasuOp.GetVertexByIndex(theShape, theIndex)
6929             RaiseIfFailed("GetVertexByIndex", self.MeasuOp)
6930             return anObj
6931
6932         ## Get the first vertex of wire/edge depended orientation.
6933         #  @param theShape Shape to find first vertex.
6934         #  @return New GEOM.GEOM_Object, containing the created vertex.
6935         #
6936         #  @ref tui_measurement_tools_page "Example"
6937         def GetFirstVertex(self,theShape):
6938             """
6939             Get the first vertex of wire/edge depended orientation.
6940
6941             Parameters:
6942                 theShape Shape to find first vertex.
6943
6944             Returns:
6945                 New GEOM.GEOM_Object, containing the created vertex.
6946             """
6947             # Example: see GEOM_TestMeasures.py
6948             anObj = self.GetVertexByIndex(theShape, 0)
6949             RaiseIfFailed("GetFirstVertex", self.MeasuOp)
6950             return anObj
6951
6952         ## Get the last vertex of wire/edge depended orientation.
6953         #  @param theShape Shape to find last vertex.
6954         #  @return New GEOM.GEOM_Object, containing the created vertex.
6955         #
6956         #  @ref tui_measurement_tools_page "Example"
6957         def GetLastVertex(self,theShape):
6958             """
6959             Get the last vertex of wire/edge depended orientation.
6960
6961             Parameters:
6962                 theShape Shape to find last vertex.
6963
6964             Returns:
6965                 New GEOM.GEOM_Object, containing the created vertex.
6966             """
6967             # Example: see GEOM_TestMeasures.py
6968             nb_vert =  self.ShapesOp.NumberOfSubShapes(theShape, ShapeType["VERTEX"])
6969             anObj = self.GetVertexByIndex(theShape, (nb_vert-1))
6970             RaiseIfFailed("GetLastVertex", self.MeasuOp)
6971             return anObj
6972
6973         ## Get a normale to the given face. If the point is not given,
6974         #  the normale is calculated at the center of mass.
6975         #  @param theFace Face to define normale of.
6976         #  @param theOptionalPoint Point to compute the normale at.
6977         #  @return New GEOM.GEOM_Object, containing the created vector.
6978         #
6979         #  @ref swig_todo "Example"
6980         def GetNormal(self, theFace, theOptionalPoint = None):
6981             """
6982             Get a normale to the given face. If the point is not given,
6983             the normale is calculated at the center of mass.
6984
6985             Parameters:
6986                 theFace Face to define normale of.
6987                 theOptionalPoint Point to compute the normale at.
6988
6989             Returns:
6990                 New GEOM.GEOM_Object, containing the created vector.
6991             """
6992             # Example: see GEOM_TestMeasures.py
6993             anObj = self.MeasuOp.GetNormal(theFace, theOptionalPoint)
6994             RaiseIfFailed("GetNormal", self.MeasuOp)
6995             return anObj
6996
6997         ## Check a topology of the given shape.
6998         #  @param theShape Shape to check validity of.
6999         #  @param theIsCheckGeom If FALSE, only the shape's topology will be checked, \n
7000         #                        if TRUE, the shape's geometry will be checked also.
7001         #  @param theReturnStatus If FALSE and if theShape is invalid, a description \n
7002         #                        of problem is printed.
7003         #                        if TRUE and if theShape is invalid, the description
7004         #                        of problem is also returned.
7005         #  @return TRUE, if the shape "seems to be valid".
7006         #
7007         #  @ref tui_measurement_tools_page "Example"
7008         def CheckShape(self,theShape, theIsCheckGeom = 0, theReturnStatus = 0):
7009             """
7010             Check a topology of the given shape.
7011
7012             Parameters:
7013                 theShape Shape to check validity of.
7014                 theIsCheckGeom If FALSE, only the shape's topology will be checked,
7015                                if TRUE, the shape's geometry will be checked also.
7016                 theReturnStatus If FALSE and if theShape is invalid, a description
7017                                 of problem is printed.
7018                                 if TRUE and if theShape is invalid, the description
7019                                 of problem is returned.
7020
7021             Returns:
7022                 TRUE, if the shape "seems to be valid".
7023                 If theShape is invalid, prints a description of problem.
7024                 This description can also be returned.
7025             """
7026             # Example: see GEOM_TestMeasures.py
7027             if theIsCheckGeom:
7028                 (IsValid, Status) = self.MeasuOp.CheckShapeWithGeometry(theShape)
7029                 RaiseIfFailed("CheckShapeWithGeometry", self.MeasuOp)
7030             else:
7031                 (IsValid, Status) = self.MeasuOp.CheckShape(theShape)
7032                 RaiseIfFailed("CheckShape", self.MeasuOp)
7033             if IsValid == 0:
7034                 if theReturnStatus == 0:
7035                     print Status
7036             if theReturnStatus == 1:
7037               return (IsValid, Status)
7038             return IsValid
7039
7040         ## Detect self-intersections in the given shape.
7041         #  @param theShape Shape to check.
7042         #  @return TRUE, if the shape contains no self-intersections.
7043         #
7044         #  @ref tui_measurement_tools_page "Example"
7045         def CheckSelfIntersections(self, theShape):
7046             """
7047             Detect self-intersections in the given shape.
7048
7049             Parameters:
7050                 theShape Shape to check.
7051
7052             Returns:
7053                 TRUE, if the shape contains no self-intersections.
7054             """
7055             # Example: see GEOM_TestMeasures.py
7056             (IsValid, Pairs) = self.MeasuOp.CheckSelfIntersections(theShape)
7057             RaiseIfFailed("CheckSelfIntersections", self.MeasuOp)
7058             return IsValid
7059
7060         ## Get position (LCS) of theShape.
7061         #
7062         #  Origin of the LCS is situated at the shape's center of mass.
7063         #  Axes of the LCS are obtained from shape's location or,
7064         #  if the shape is a planar face, from position of its plane.
7065         #
7066         #  @param theShape Shape to calculate position of.
7067         #  @return [Ox,Oy,Oz, Zx,Zy,Zz, Xx,Xy,Xz].
7068         #          Ox,Oy,Oz: Coordinates of shape's LCS origin.
7069         #          Zx,Zy,Zz: Coordinates of shape's LCS normal(main) direction.
7070         #          Xx,Xy,Xz: Coordinates of shape's LCS X direction.
7071         #
7072         #  @ref swig_todo "Example"
7073         def GetPosition(self,theShape):
7074             """
7075             Get position (LCS) of theShape.
7076             Origin of the LCS is situated at the shape's center of mass.
7077             Axes of the LCS are obtained from shape's location or,
7078             if the shape is a planar face, from position of its plane.
7079
7080             Parameters:
7081                 theShape Shape to calculate position of.
7082
7083             Returns:
7084                 [Ox,Oy,Oz, Zx,Zy,Zz, Xx,Xy,Xz].
7085                  Ox,Oy,Oz: Coordinates of shape's LCS origin.
7086                  Zx,Zy,Zz: Coordinates of shape's LCS normal(main) direction.
7087                  Xx,Xy,Xz: Coordinates of shape's LCS X direction.
7088             """
7089             # Example: see GEOM_TestMeasures.py
7090             aTuple = self.MeasuOp.GetPosition(theShape)
7091             RaiseIfFailed("GetPosition", self.MeasuOp)
7092             return aTuple
7093
7094         ## Get kind of theShape.
7095         #
7096         #  @param theShape Shape to get a kind of.
7097         #  @return Returns a kind of shape in terms of <VAR>GEOM.GEOM_IKindOfShape.shape_kind</VAR> enumeration
7098         #          and a list of parameters, describing the shape.
7099         #  @note  Concrete meaning of each value, returned via \a theIntegers
7100         #         or \a theDoubles list depends on the kind() of the shape.
7101         #
7102         #  @ref swig_todo "Example"
7103         def KindOfShape(self,theShape):
7104             """
7105             Get kind of theShape.
7106
7107             Parameters:
7108                 theShape Shape to get a kind of.
7109
7110             Returns:
7111                 a kind of shape in terms of GEOM_IKindOfShape.shape_kind enumeration
7112                     and a list of parameters, describing the shape.
7113             Note:
7114                 Concrete meaning of each value, returned via theIntegers
7115                 or theDoubles list depends on the geompy.kind of the shape
7116             """
7117             # Example: see GEOM_TestMeasures.py
7118             aRoughTuple = self.MeasuOp.KindOfShape(theShape)
7119             RaiseIfFailed("KindOfShape", self.MeasuOp)
7120
7121             aKind  = aRoughTuple[0]
7122             anInts = aRoughTuple[1]
7123             aDbls  = aRoughTuple[2]
7124
7125             # Now there is no exception from this rule:
7126             aKindTuple = [aKind] + aDbls + anInts
7127
7128             # If they are we will regroup parameters for such kind of shape.
7129             # For example:
7130             #if aKind == kind.SOME_KIND:
7131             #    #  SOME_KIND     int int double int double double
7132             #    aKindTuple = [aKind, anInts[0], anInts[1], aDbls[0], anInts[2], aDbls[1], aDbls[2]]
7133
7134             return aKindTuple
7135
7136         # end of l2_measure
7137         ## @}
7138
7139         ## @addtogroup l2_import_export
7140         ## @{
7141
7142         ## Import a shape from the BREP or IGES or STEP file
7143         #  (depends on given format) with given name.
7144         #  @param theFileName The file, containing the shape.
7145         #  @param theFormatName Specify format for the file reading.
7146         #         Available formats can be obtained with InsertOp.ImportTranslators() method.
7147         #         If format 'IGES_SCALE' is used instead 'IGES' length unit will be
7148         #         set to 'meter' and result model will be scaled.
7149         #  @return New GEOM.GEOM_Object, containing the imported shape.
7150         #
7151         #  @ref swig_Import_Export "Example"
7152         def ImportFile(self,theFileName, theFormatName):
7153             """
7154             Import a shape from the BREP or IGES or STEP file
7155             (depends on given format) with given name.
7156
7157             Parameters:
7158                 theFileName The file, containing the shape.
7159                 theFormatName Specify format for the file reading.
7160                               Available formats can be obtained with geompy.InsertOp.ImportTranslators() method.
7161                               If format 'IGES_SCALE' is used instead 'IGES' length unit will be
7162                               set to 'meter' and result model will be scaled.
7163
7164             Returns:
7165                 New GEOM.GEOM_Object, containing the imported shape.
7166             """
7167             # Example: see GEOM_TestOthers.py
7168             anObj = self.InsertOp.ImportFile(theFileName, theFormatName)
7169             RaiseIfFailed("Import", self.InsertOp)
7170             return anObj
7171
7172         ## Deprecated analog of ImportFile()
7173         def Import(self,theFileName, theFormatName):
7174             """
7175             Deprecated analog of geompy.ImportFile
7176             """
7177             print "WARNING: Function Import is deprecated, use ImportFile instead"
7178             anObj = self.InsertOp.ImportFile(theFileName, theFormatName)
7179             RaiseIfFailed("Import", self.InsertOp)
7180             return anObj
7181
7182         ## Shortcut to ImportFile() for BREP format
7183         #
7184         #  @ref swig_Import_Export "Example"
7185         def ImportBREP(self,theFileName):
7186             """
7187             geompy.ImportFile(...) function for BREP format
7188             """
7189             # Example: see GEOM_TestOthers.py
7190             return self.ImportFile(theFileName, "BREP")
7191
7192         ## Shortcut to ImportFile() for IGES format
7193         #
7194         #  @ref swig_Import_Export "Example"
7195         def ImportIGES(self,theFileName):
7196             """
7197             geompy.ImportFile(...) function for IGES format
7198             """
7199             # Example: see GEOM_TestOthers.py
7200             return self.ImportFile(theFileName, "IGES")
7201
7202         ## Return length unit from given IGES file
7203         #
7204         #  @ref swig_Import_Export "Example"
7205         def GetIGESUnit(self,theFileName):
7206             """
7207             Return length unit from given IGES file
7208             """
7209             # Example: see GEOM_TestOthers.py
7210             anObj = self.InsertOp.ImportFile(theFileName, "IGES_UNIT")
7211             #RaiseIfFailed("Import", self.InsertOp)
7212             # recieve name using returned vertex
7213             UnitName = "M"
7214             if anObj.GetShapeType() == GEOM.VERTEX:
7215                 vertices = [anObj]
7216             else:
7217                 vertices = self.SubShapeAll(anObj,ShapeType["VERTEX"])
7218             if len(vertices)>0:
7219                 p = self.PointCoordinates(vertices[0])
7220                 if abs(p[0]-0.01) < 1.e-6:
7221                     UnitName = "CM"
7222                 elif abs(p[0]-0.001) < 1.e-6:
7223                     UnitName = "MM"
7224             return UnitName
7225
7226         ## Shortcut to ImportFile() for STEP format
7227         #
7228         #  @ref swig_Import_Export "Example"
7229         def ImportSTEP(self,theFileName):
7230             """
7231             geompy.ImportFile(...) function for STEP format
7232             """
7233             # Example: see GEOM_TestOthers.py
7234             return self.ImportFile(theFileName, "STEP")
7235
7236         ## Export the given shape into a file with given name.
7237         #  @param theObject Shape to be stored in the file.
7238         #  @param theFileName Name of the file to store the given shape in.
7239         #  @param theFormatName Specify format for the shape storage.
7240         #         Available formats can be obtained with InsertOp.ImportTranslators() method.
7241         #
7242         #  @ref swig_Import_Export "Example"
7243         def Export(self,theObject, theFileName, theFormatName):
7244             """
7245             Export the given shape into a file with given name.
7246
7247             Parameters:
7248                 theObject Shape to be stored in the file.
7249                 theFileName Name of the file to store the given shape in.
7250                 theFormatName Specify format for the shape storage.
7251                               Available formats can be obtained with geompy.InsertOp.ImportTranslators() method.
7252             """
7253             # Example: see GEOM_TestOthers.py
7254             self.InsertOp.Export(theObject, theFileName, theFormatName)
7255             if self.InsertOp.IsDone() == 0:
7256                 raise RuntimeError,  "Export : " + self.InsertOp.GetErrorCode()
7257                 pass
7258             pass
7259
7260         ## Shortcut to Export() for BREP format
7261         #
7262         #  @ref swig_Import_Export "Example"
7263         def ExportBREP(self,theObject, theFileName):
7264             """
7265             geompy.Export(...) function for BREP format
7266             """
7267             # Example: see GEOM_TestOthers.py
7268             return self.Export(theObject, theFileName, "BREP")
7269
7270         ## Shortcut to Export() for IGES format
7271         #
7272         #  @ref swig_Import_Export "Example"
7273         def ExportIGES(self,theObject, theFileName):
7274             """
7275             geompy.Export(...) function for IGES format
7276             """
7277             # Example: see GEOM_TestOthers.py
7278             return self.Export(theObject, theFileName, "IGES")
7279
7280         ## Shortcut to Export() for STEP format
7281         #
7282         #  @ref swig_Import_Export "Example"
7283         def ExportSTEP(self,theObject, theFileName):
7284             """
7285             geompy.Export(...) function for STEP format
7286             """
7287             # Example: see GEOM_TestOthers.py
7288             return self.Export(theObject, theFileName, "STEP")
7289
7290         # end of l2_import_export
7291         ## @}
7292
7293         ## @addtogroup l3_blocks
7294         ## @{
7295
7296         ## Create a quadrangle face from four edges. Order of Edges is not
7297         #  important. It is  not necessary that edges share the same vertex.
7298         #  @param E1,E2,E3,E4 Edges for the face bound.
7299         #  @return New GEOM.GEOM_Object, containing the created face.
7300         #
7301         #  @ref tui_building_by_blocks_page "Example"
7302         def MakeQuad(self,E1, E2, E3, E4):
7303             """
7304             Create a quadrangle face from four edges. Order of Edges is not
7305             important. It is  not necessary that edges share the same vertex.
7306
7307             Parameters:
7308                 E1,E2,E3,E4 Edges for the face bound.
7309
7310             Returns:
7311                 New GEOM.GEOM_Object, containing the created face.
7312
7313             Example of usage:
7314                 qface1 = geompy.MakeQuad(edge1, edge2, edge3, edge4)
7315             """
7316             # Example: see GEOM_Spanner.py
7317             anObj = self.BlocksOp.MakeQuad(E1, E2, E3, E4)
7318             RaiseIfFailed("MakeQuad", self.BlocksOp)
7319             return anObj
7320
7321         ## Create a quadrangle face on two edges.
7322         #  The missing edges will be built by creating the shortest ones.
7323         #  @param E1,E2 Two opposite edges for the face.
7324         #  @return New GEOM.GEOM_Object, containing the created face.
7325         #
7326         #  @ref tui_building_by_blocks_page "Example"
7327         def MakeQuad2Edges(self,E1, E2):
7328             """
7329             Create a quadrangle face on two edges.
7330             The missing edges will be built by creating the shortest ones.
7331
7332             Parameters:
7333                 E1,E2 Two opposite edges for the face.
7334
7335             Returns:
7336                 New GEOM.GEOM_Object, containing the created face.
7337
7338             Example of usage:
7339                 # create vertices
7340                 p1 = geompy.MakeVertex(  0.,   0.,   0.)
7341                 p2 = geompy.MakeVertex(150.,  30.,   0.)
7342                 p3 = geompy.MakeVertex(  0., 120.,  50.)
7343                 p4 = geompy.MakeVertex(  0.,  40.,  70.)
7344                 # create edges
7345                 edge1 = geompy.MakeEdge(p1, p2)
7346                 edge2 = geompy.MakeEdge(p3, p4)
7347                 # create a quadrangle face from two edges
7348                 qface2 = geompy.MakeQuad2Edges(edge1, edge2)
7349             """
7350             # Example: see GEOM_Spanner.py
7351             anObj = self.BlocksOp.MakeQuad2Edges(E1, E2)
7352             RaiseIfFailed("MakeQuad2Edges", self.BlocksOp)
7353             return anObj
7354
7355         ## Create a quadrangle face with specified corners.
7356         #  The missing edges will be built by creating the shortest ones.
7357         #  @param V1,V2,V3,V4 Corner vertices for the face.
7358         #  @return New GEOM.GEOM_Object, containing the created face.
7359         #
7360         #  @ref tui_building_by_blocks_page "Example 1"
7361         #  \n @ref swig_MakeQuad4Vertices "Example 2"
7362         def MakeQuad4Vertices(self,V1, V2, V3, V4):
7363             """
7364             Create a quadrangle face with specified corners.
7365             The missing edges will be built by creating the shortest ones.
7366
7367             Parameters:
7368                 V1,V2,V3,V4 Corner vertices for the face.
7369
7370             Returns:
7371                 New GEOM.GEOM_Object, containing the created face.
7372
7373             Example of usage:
7374                 # create vertices
7375                 p1 = geompy.MakeVertex(  0.,   0.,   0.)
7376                 p2 = geompy.MakeVertex(150.,  30.,   0.)
7377                 p3 = geompy.MakeVertex(  0., 120.,  50.)
7378                 p4 = geompy.MakeVertex(  0.,  40.,  70.)
7379                 # create a quadrangle from four points in its corners
7380                 qface3 = geompy.MakeQuad4Vertices(p1, p2, p3, p4)
7381             """
7382             # Example: see GEOM_Spanner.py
7383             anObj = self.BlocksOp.MakeQuad4Vertices(V1, V2, V3, V4)
7384             RaiseIfFailed("MakeQuad4Vertices", self.BlocksOp)
7385             return anObj
7386
7387         ## Create a hexahedral solid, bounded by the six given faces. Order of
7388         #  faces is not important. It is  not necessary that Faces share the same edge.
7389         #  @param F1,F2,F3,F4,F5,F6 Faces for the hexahedral solid.
7390         #  @return New GEOM.GEOM_Object, containing the created solid.
7391         #
7392         #  @ref tui_building_by_blocks_page "Example 1"
7393         #  \n @ref swig_MakeHexa "Example 2"
7394         def MakeHexa(self,F1, F2, F3, F4, F5, F6):
7395             """
7396             Create a hexahedral solid, bounded by the six given faces. Order of
7397             faces is not important. It is  not necessary that Faces share the same edge.
7398
7399             Parameters:
7400                 F1,F2,F3,F4,F5,F6 Faces for the hexahedral solid.
7401
7402             Returns:
7403                 New GEOM.GEOM_Object, containing the created solid.
7404
7405             Example of usage:
7406                 solid = geompy.MakeHexa(qface1, qface2, qface3, qface4, qface5, qface6)
7407             """
7408             # Example: see GEOM_Spanner.py
7409             anObj = self.BlocksOp.MakeHexa(F1, F2, F3, F4, F5, F6)
7410             RaiseIfFailed("MakeHexa", self.BlocksOp)
7411             return anObj
7412
7413         ## Create a hexahedral solid between two given faces.
7414         #  The missing faces will be built by creating the smallest ones.
7415         #  @param F1,F2 Two opposite faces for the hexahedral solid.
7416         #  @return New GEOM.GEOM_Object, containing the created solid.
7417         #
7418         #  @ref tui_building_by_blocks_page "Example 1"
7419         #  \n @ref swig_MakeHexa2Faces "Example 2"
7420         def MakeHexa2Faces(self,F1, F2):
7421             """
7422             Create a hexahedral solid between two given faces.
7423             The missing faces will be built by creating the smallest ones.
7424
7425             Parameters:
7426                 F1,F2 Two opposite faces for the hexahedral solid.
7427
7428             Returns:
7429                 New GEOM.GEOM_Object, containing the created solid.
7430
7431             Example of usage:
7432                 solid1 = geompy.MakeHexa2Faces(qface1, qface2)
7433             """
7434             # Example: see GEOM_Spanner.py
7435             anObj = self.BlocksOp.MakeHexa2Faces(F1, F2)
7436             RaiseIfFailed("MakeHexa2Faces", self.BlocksOp)
7437             return anObj
7438
7439         # end of l3_blocks
7440         ## @}
7441
7442         ## @addtogroup l3_blocks_op
7443         ## @{
7444
7445         ## Get a vertex, found in the given shape by its coordinates.
7446         #  @param theShape Block or a compound of blocks.
7447         #  @param theX,theY,theZ Coordinates of the sought vertex.
7448         #  @param theEpsilon Maximum allowed distance between the resulting
7449         #                    vertex and point with the given coordinates.
7450         #  @return New GEOM.GEOM_Object, containing the found vertex.
7451         #
7452         #  @ref swig_GetPoint "Example"
7453         def GetPoint(self, theShape, theX, theY, theZ, theEpsilon):
7454             """
7455             Get a vertex, found in the given shape by its coordinates.
7456
7457             Parameters:
7458                 theShape Block or a compound of blocks.
7459                 theX,theY,theZ Coordinates of the sought vertex.
7460                 theEpsilon Maximum allowed distance between the resulting
7461                            vertex and point with the given coordinates.
7462
7463             Returns:
7464                 New GEOM.GEOM_Object, containing the found vertex.
7465
7466             Example of usage:
7467                 pnt = geompy.GetPoint(shape, -50,  50,  50, 0.01)
7468             """
7469             # Example: see GEOM_TestOthers.py
7470             anObj = self.BlocksOp.GetPoint(theShape, theX, theY, theZ, theEpsilon)
7471             RaiseIfFailed("GetPoint", self.BlocksOp)
7472             return anObj
7473
7474         ## Find a vertex of the given shape, which has minimal distance to the given point.
7475         #  @param theShape Any shape.
7476         #  @param thePoint Point, close to the desired vertex.
7477         #  @return New GEOM.GEOM_Object, containing the found vertex.
7478         #
7479         #  @ref swig_GetVertexNearPoint "Example"
7480         def GetVertexNearPoint(self, theShape, thePoint):
7481             """
7482             Find a vertex of the given shape, which has minimal distance to the given point.
7483
7484             Parameters:
7485                 theShape Any shape.
7486                 thePoint Point, close to the desired vertex.
7487
7488             Returns:
7489                 New GEOM.GEOM_Object, containing the found vertex.
7490
7491             Example of usage:
7492                 pmidle = geompy.MakeVertex(50, 0, 50)
7493                 edge1 = geompy.GetEdgeNearPoint(blocksComp, pmidle)
7494             """
7495             # Example: see GEOM_TestOthers.py
7496             anObj = self.BlocksOp.GetVertexNearPoint(theShape, thePoint)
7497             RaiseIfFailed("GetVertexNearPoint", self.BlocksOp)
7498             return anObj
7499
7500         ## Get an edge, found in the given shape by two given vertices.
7501         #  @param theShape Block or a compound of blocks.
7502         #  @param thePoint1,thePoint2 Points, close to the ends of the desired edge.
7503         #  @return New GEOM.GEOM_Object, containing the found edge.
7504         #
7505         #  @ref swig_GetEdge "Example"
7506         def GetEdge(self, theShape, thePoint1, thePoint2):
7507             """
7508             Get an edge, found in the given shape by two given vertices.
7509
7510             Parameters:
7511                 theShape Block or a compound of blocks.
7512                 thePoint1,thePoint2 Points, close to the ends of the desired edge.
7513
7514             Returns:
7515                 New GEOM.GEOM_Object, containing the found edge.
7516             """
7517             # Example: see GEOM_Spanner.py
7518             anObj = self.BlocksOp.GetEdge(theShape, thePoint1, thePoint2)
7519             RaiseIfFailed("GetEdge", self.BlocksOp)
7520             return anObj
7521
7522         ## Find an edge of the given shape, which has minimal distance to the given point.
7523         #  @param theShape Block or a compound of blocks.
7524         #  @param thePoint Point, close to the desired edge.
7525         #  @return New GEOM.GEOM_Object, containing the found edge.
7526         #
7527         #  @ref swig_GetEdgeNearPoint "Example"
7528         def GetEdgeNearPoint(self, theShape, thePoint):
7529             """
7530             Find an edge of the given shape, which has minimal distance to the given point.
7531
7532             Parameters:
7533                 theShape Block or a compound of blocks.
7534                 thePoint Point, close to the desired edge.
7535
7536             Returns:
7537                 New GEOM.GEOM_Object, containing the found edge.
7538             """
7539             # Example: see GEOM_TestOthers.py
7540             anObj = self.BlocksOp.GetEdgeNearPoint(theShape, thePoint)
7541             RaiseIfFailed("GetEdgeNearPoint", self.BlocksOp)
7542             return anObj
7543
7544         ## Returns a face, found in the given shape by four given corner vertices.
7545         #  @param theShape Block or a compound of blocks.
7546         #  @param thePoint1,thePoint2,thePoint3,thePoint4 Points, close to the corners of the desired face.
7547         #  @return New GEOM.GEOM_Object, containing the found face.
7548         #
7549         #  @ref swig_todo "Example"
7550         def GetFaceByPoints(self,theShape, thePoint1, thePoint2, thePoint3, thePoint4):
7551             """
7552             Returns a face, found in the given shape by four given corner vertices.
7553
7554             Parameters:
7555                 theShape Block or a compound of blocks.
7556                 thePoint1,thePoint2,thePoint3,thePoint4 Points, close to the corners of the desired face.
7557
7558             Returns:
7559                 New GEOM.GEOM_Object, containing the found face.
7560             """
7561             # Example: see GEOM_Spanner.py
7562             anObj = self.BlocksOp.GetFaceByPoints(theShape, thePoint1, thePoint2, thePoint3, thePoint4)
7563             RaiseIfFailed("GetFaceByPoints", self.BlocksOp)
7564             return anObj
7565
7566         ## Get a face of block, found in the given shape by two given edges.
7567         #  @param theShape Block or a compound of blocks.
7568         #  @param theEdge1,theEdge2 Edges, close to the edges of the desired face.
7569         #  @return New GEOM.GEOM_Object, containing the found face.
7570         #
7571         #  @ref swig_todo "Example"
7572         def GetFaceByEdges(self,theShape, theEdge1, theEdge2):
7573             """
7574             Get a face of block, found in the given shape by two given edges.
7575
7576             Parameters:
7577                 theShape Block or a compound of blocks.
7578                 theEdge1,theEdge2 Edges, close to the edges of the desired face.
7579
7580             Returns:
7581                 New GEOM.GEOM_Object, containing the found face.
7582             """
7583             # Example: see GEOM_Spanner.py
7584             anObj = self.BlocksOp.GetFaceByEdges(theShape, theEdge1, theEdge2)
7585             RaiseIfFailed("GetFaceByEdges", self.BlocksOp)
7586             return anObj
7587
7588         ## Find a face, opposite to the given one in the given block.
7589         #  @param theBlock Must be a hexahedral solid.
7590         #  @param theFace Face of \a theBlock, opposite to the desired face.
7591         #  @return New GEOM.GEOM_Object, containing the found face.
7592         #
7593         #  @ref swig_GetOppositeFace "Example"
7594         def GetOppositeFace(self,theBlock, theFace):
7595             """
7596             Find a face, opposite to the given one in the given block.
7597
7598             Parameters:
7599                 theBlock Must be a hexahedral solid.
7600                 theFace Face of theBlock, opposite to the desired face.
7601
7602             Returns:
7603                 New GEOM.GEOM_Object, containing the found face.
7604             """
7605             # Example: see GEOM_Spanner.py
7606             anObj = self.BlocksOp.GetOppositeFace(theBlock, theFace)
7607             RaiseIfFailed("GetOppositeFace", self.BlocksOp)
7608             return anObj
7609
7610         ## Find a face of the given shape, which has minimal distance to the given point.
7611         #  @param theShape Block or a compound of blocks.
7612         #  @param thePoint Point, close to the desired face.
7613         #  @return New GEOM.GEOM_Object, containing the found face.
7614         #
7615         #  @ref swig_GetFaceNearPoint "Example"
7616         def GetFaceNearPoint(self, theShape, thePoint):
7617             """
7618             Find a face of the given shape, which has minimal distance to the given point.
7619
7620             Parameters:
7621                 theShape Block or a compound of blocks.
7622                 thePoint Point, close to the desired face.
7623
7624             Returns:
7625                 New GEOM.GEOM_Object, containing the found face.
7626             """
7627             # Example: see GEOM_Spanner.py
7628             anObj = self.BlocksOp.GetFaceNearPoint(theShape, thePoint)
7629             RaiseIfFailed("GetFaceNearPoint", self.BlocksOp)
7630             return anObj
7631
7632         ## Find a face of block, whose outside normale has minimal angle with the given vector.
7633         #  @param theBlock Block or a compound of blocks.
7634         #  @param theVector Vector, close to the normale of the desired face.
7635         #  @return New GEOM.GEOM_Object, containing the found face.
7636         #
7637         #  @ref swig_todo "Example"
7638         def GetFaceByNormale(self, theBlock, theVector):
7639             """
7640             Find a face of block, whose outside normale has minimal angle with the given vector.
7641
7642             Parameters:
7643                 theBlock Block or a compound of blocks.
7644                 theVector Vector, close to the normale of the desired face.
7645
7646             Returns:
7647                 New GEOM.GEOM_Object, containing the found face.
7648             """
7649             # Example: see GEOM_Spanner.py
7650             anObj = self.BlocksOp.GetFaceByNormale(theBlock, theVector)
7651             RaiseIfFailed("GetFaceByNormale", self.BlocksOp)
7652             return anObj
7653
7654         ## Find all sub-shapes of type \a theShapeType of the given shape,
7655         #  which have minimal distance to the given point.
7656         #  @param theShape Any shape.
7657         #  @param thePoint Point, close to the desired shape.
7658         #  @param theShapeType Defines what kind of sub-shapes is searched GEOM::shape_type
7659         #  @param theTolerance The tolerance for distances comparison. All shapes
7660         #                      with distances to the given point in interval
7661         #                      [minimal_distance, minimal_distance + theTolerance] will be gathered.
7662         #  @return New GEOM_Object, containing a group of all found shapes.
7663         #
7664         #  @ref swig_GetShapesNearPoint "Example"
7665         def GetShapesNearPoint(self, theShape, thePoint, theShapeType, theTolerance = 1e-07):
7666             """
7667             Find all sub-shapes of type theShapeType of the given shape,
7668             which have minimal distance to the given point.
7669
7670             Parameters:
7671                 theShape Any shape.
7672                 thePoint Point, close to the desired shape.
7673                 theShapeType Defines what kind of sub-shapes is searched (see GEOM::shape_type)
7674                 theTolerance The tolerance for distances comparison. All shapes
7675                                 with distances to the given point in interval
7676                                 [minimal_distance, minimal_distance + theTolerance] will be gathered.
7677
7678             Returns:
7679                 New GEOM_Object, containing a group of all found shapes.
7680             """
7681             # Example: see GEOM_TestOthers.py
7682             anObj = self.BlocksOp.GetShapesNearPoint(theShape, thePoint, theShapeType, theTolerance)
7683             RaiseIfFailed("GetShapesNearPoint", self.BlocksOp)
7684             return anObj
7685
7686         # end of l3_blocks_op
7687         ## @}
7688
7689         ## @addtogroup l4_blocks_measure
7690         ## @{
7691
7692         ## Check, if the compound of blocks is given.
7693         #  To be considered as a compound of blocks, the
7694         #  given shape must satisfy the following conditions:
7695         #  - Each element of the compound should be a Block (6 faces and 12 edges).
7696         #  - A connection between two Blocks should be an entire quadrangle face or an entire edge.
7697         #  - The compound should be connexe.
7698         #  - The glue between two quadrangle faces should be applied.
7699         #  @param theCompound The compound to check.
7700         #  @return TRUE, if the given shape is a compound of blocks.
7701         #  If theCompound is not valid, prints all discovered errors.
7702         #
7703         #  @ref tui_measurement_tools_page "Example 1"
7704         #  \n @ref swig_CheckCompoundOfBlocks "Example 2"
7705         def CheckCompoundOfBlocks(self,theCompound):
7706             """
7707             Check, if the compound of blocks is given.
7708             To be considered as a compound of blocks, the
7709             given shape must satisfy the following conditions:
7710             - Each element of the compound should be a Block (6 faces and 12 edges).
7711             - A connection between two Blocks should be an entire quadrangle face or an entire edge.
7712             - The compound should be connexe.
7713             - The glue between two quadrangle faces should be applied.
7714
7715             Parameters:
7716                 theCompound The compound to check.
7717
7718             Returns:
7719                 TRUE, if the given shape is a compound of blocks.
7720                 If theCompound is not valid, prints all discovered errors.
7721             """
7722             # Example: see GEOM_Spanner.py
7723             (IsValid, BCErrors) = self.BlocksOp.CheckCompoundOfBlocks(theCompound)
7724             RaiseIfFailed("CheckCompoundOfBlocks", self.BlocksOp)
7725             if IsValid == 0:
7726                 Descr = self.BlocksOp.PrintBCErrors(theCompound, BCErrors)
7727                 print Descr
7728             return IsValid
7729
7730         ## Remove all seam and degenerated edges from \a theShape.
7731         #  Unite faces and edges, sharing one surface. It means that
7732         #  this faces must have references to one C++ surface object (handle).
7733         #  @param theShape The compound or single solid to remove irregular edges from.
7734         #  @param doUnionFaces If True, then unite faces. If False (the default value),
7735         #         do not unite faces.
7736         #  @return Improved shape.
7737         #
7738         #  @ref swig_RemoveExtraEdges "Example"
7739         def RemoveExtraEdges(self, theShape, doUnionFaces=False):
7740             """
7741             Remove all seam and degenerated edges from theShape.
7742             Unite faces and edges, sharing one surface. It means that
7743             this faces must have references to one C++ surface object (handle).
7744
7745             Parameters:
7746                 theShape The compound or single solid to remove irregular edges from.
7747                 doUnionFaces If True, then unite faces. If False (the default value),
7748                              do not unite faces.
7749
7750             Returns:
7751                 Improved shape.
7752             """
7753             # Example: see GEOM_TestOthers.py
7754             nbFacesOptimum = -1 # -1 means do not unite faces
7755             if doUnionFaces is True: nbFacesOptimum = 0 # 0 means unite faces
7756             anObj = self.BlocksOp.RemoveExtraEdges(theShape, nbFacesOptimum)
7757             RaiseIfFailed("RemoveExtraEdges", self.BlocksOp)
7758             return anObj
7759
7760         ## Check, if the given shape is a blocks compound.
7761         #  Fix all detected errors.
7762         #    \note Single block can be also fixed by this method.
7763         #  @param theShape The compound to check and improve.
7764         #  @return Improved compound.
7765         #
7766         #  @ref swig_CheckAndImprove "Example"
7767         def CheckAndImprove(self,theShape):
7768             """
7769             Check, if the given shape is a blocks compound.
7770             Fix all detected errors.
7771
7772             Note:
7773                 Single block can be also fixed by this method.
7774
7775             Parameters:
7776                 theShape The compound to check and improve.
7777
7778             Returns:
7779                 Improved compound.
7780             """
7781             # Example: see GEOM_TestOthers.py
7782             anObj = self.BlocksOp.CheckAndImprove(theShape)
7783             RaiseIfFailed("CheckAndImprove", self.BlocksOp)
7784             return anObj
7785
7786         # end of l4_blocks_measure
7787         ## @}
7788
7789         ## @addtogroup l3_blocks_op
7790         ## @{
7791
7792         ## Get all the blocks, contained in the given compound.
7793         #  @param theCompound The compound to explode.
7794         #  @param theMinNbFaces If solid has lower number of faces, it is not a block.
7795         #  @param theMaxNbFaces If solid has higher number of faces, it is not a block.
7796         #    \note If theMaxNbFaces = 0, the maximum number of faces is not restricted.
7797         #  @return List of GEOM.GEOM_Object, containing the retrieved blocks.
7798         #
7799         #  @ref tui_explode_on_blocks "Example 1"
7800         #  \n @ref swig_MakeBlockExplode "Example 2"
7801         def MakeBlockExplode(self,theCompound, theMinNbFaces, theMaxNbFaces):
7802             """
7803             Get all the blocks, contained in the given compound.
7804
7805             Parameters:
7806                 theCompound The compound to explode.
7807                 theMinNbFaces If solid has lower number of faces, it is not a block.
7808                 theMaxNbFaces If solid has higher number of faces, it is not a block.
7809
7810             Note:
7811                 If theMaxNbFaces = 0, the maximum number of faces is not restricted.
7812
7813             Returns:
7814                 List of GEOM.GEOM_Object, containing the retrieved blocks.
7815             """
7816             # Example: see GEOM_TestOthers.py
7817             theMinNbFaces,theMaxNbFaces,Parameters = ParseParameters(theMinNbFaces,theMaxNbFaces)
7818             aList = self.BlocksOp.ExplodeCompoundOfBlocks(theCompound, theMinNbFaces, theMaxNbFaces)
7819             RaiseIfFailed("ExplodeCompoundOfBlocks", self.BlocksOp)
7820             for anObj in aList:
7821                 anObj.SetParameters(Parameters)
7822                 pass
7823             return aList
7824
7825         ## Find block, containing the given point inside its volume or on boundary.
7826         #  @param theCompound Compound, to find block in.
7827         #  @param thePoint Point, close to the desired block. If the point lays on
7828         #         boundary between some blocks, we return block with nearest center.
7829         #  @return New GEOM.GEOM_Object, containing the found block.
7830         #
7831         #  @ref swig_todo "Example"
7832         def GetBlockNearPoint(self,theCompound, thePoint):
7833             """
7834             Find block, containing the given point inside its volume or on boundary.
7835
7836             Parameters:
7837                 theCompound Compound, to find block in.
7838                 thePoint Point, close to the desired block. If the point lays on
7839                          boundary between some blocks, we return block with nearest center.
7840
7841             Returns:
7842                 New GEOM.GEOM_Object, containing the found block.
7843             """
7844             # Example: see GEOM_Spanner.py
7845             anObj = self.BlocksOp.GetBlockNearPoint(theCompound, thePoint)
7846             RaiseIfFailed("GetBlockNearPoint", self.BlocksOp)
7847             return anObj
7848
7849         ## Find block, containing all the elements, passed as the parts, or maximum quantity of them.
7850         #  @param theCompound Compound, to find block in.
7851         #  @param theParts List of faces and/or edges and/or vertices to be parts of the found block.
7852         #  @return New GEOM.GEOM_Object, containing the found block.
7853         #
7854         #  @ref swig_GetBlockByParts "Example"
7855         def GetBlockByParts(self,theCompound, theParts):
7856             """
7857              Find block, containing all the elements, passed as the parts, or maximum quantity of them.
7858
7859              Parameters:
7860                 theCompound Compound, to find block in.
7861                 theParts List of faces and/or edges and/or vertices to be parts of the found block.
7862
7863             Returns:
7864                 New GEOM_Object, containing the found block.
7865             """
7866             # Example: see GEOM_TestOthers.py
7867             anObj = self.BlocksOp.GetBlockByParts(theCompound, theParts)
7868             RaiseIfFailed("GetBlockByParts", self.BlocksOp)
7869             return anObj
7870
7871         ## Return all blocks, containing all the elements, passed as the parts.
7872         #  @param theCompound Compound, to find blocks in.
7873         #  @param theParts List of faces and/or edges and/or vertices to be parts of the found blocks.
7874         #  @return List of GEOM.GEOM_Object, containing the found blocks.
7875         #
7876         #  @ref swig_todo "Example"
7877         def GetBlocksByParts(self,theCompound, theParts):
7878             """
7879             Return all blocks, containing all the elements, passed as the parts.
7880
7881             Parameters:
7882                 theCompound Compound, to find blocks in.
7883                 theParts List of faces and/or edges and/or vertices to be parts of the found blocks.
7884
7885             Returns:
7886                 List of GEOM.GEOM_Object, containing the found blocks.
7887             """
7888             # Example: see GEOM_Spanner.py
7889             aList = self.BlocksOp.GetBlocksByParts(theCompound, theParts)
7890             RaiseIfFailed("GetBlocksByParts", self.BlocksOp)
7891             return aList
7892
7893         ## Multi-transformate block and glue the result.
7894         #  Transformation is defined so, as to superpose direction faces.
7895         #  @param Block Hexahedral solid to be multi-transformed.
7896         #  @param DirFace1 ID of First direction face.
7897         #  @param DirFace2 ID of Second direction face.
7898         #  @param NbTimes Quantity of transformations to be done.
7899         #    \note Unique ID of sub-shape can be obtained, using method GetSubShapeID().
7900         #  @return New GEOM.GEOM_Object, containing the result shape.
7901         #
7902         #  @ref tui_multi_transformation "Example"
7903         def MakeMultiTransformation1D(self,Block, DirFace1, DirFace2, NbTimes):
7904             """
7905             Multi-transformate block and glue the result.
7906             Transformation is defined so, as to superpose direction faces.
7907
7908             Parameters:
7909                 Block Hexahedral solid to be multi-transformed.
7910                 DirFace1 ID of First direction face.
7911                 DirFace2 ID of Second direction face.
7912                 NbTimes Quantity of transformations to be done.
7913
7914             Note:
7915                 Unique ID of sub-shape can be obtained, using method GetSubShapeID().
7916
7917             Returns:
7918                 New GEOM.GEOM_Object, containing the result shape.
7919             """
7920             # Example: see GEOM_Spanner.py
7921             DirFace1,DirFace2,NbTimes,Parameters = ParseParameters(DirFace1,DirFace2,NbTimes)
7922             anObj = self.BlocksOp.MakeMultiTransformation1D(Block, DirFace1, DirFace2, NbTimes)
7923             RaiseIfFailed("MakeMultiTransformation1D", self.BlocksOp)
7924             anObj.SetParameters(Parameters)
7925             return anObj
7926
7927         ## Multi-transformate block and glue the result.
7928         #  @param Block Hexahedral solid to be multi-transformed.
7929         #  @param DirFace1U,DirFace2U IDs of Direction faces for the first transformation.
7930         #  @param DirFace1V,DirFace2V IDs of Direction faces for the second transformation.
7931         #  @param NbTimesU,NbTimesV Quantity of transformations to be done.
7932         #  @return New GEOM.GEOM_Object, containing the result shape.
7933         #
7934         #  @ref tui_multi_transformation "Example"
7935         def MakeMultiTransformation2D(self,Block, DirFace1U, DirFace2U, NbTimesU,
7936                                       DirFace1V, DirFace2V, NbTimesV):
7937             """
7938             Multi-transformate block and glue the result.
7939
7940             Parameters:
7941                 Block Hexahedral solid to be multi-transformed.
7942                 DirFace1U,DirFace2U IDs of Direction faces for the first transformation.
7943                 DirFace1V,DirFace2V IDs of Direction faces for the second transformation.
7944                 NbTimesU,NbTimesV Quantity of transformations to be done.
7945
7946             Returns:
7947                 New GEOM.GEOM_Object, containing the result shape.
7948             """
7949             # Example: see GEOM_Spanner.py
7950             DirFace1U,DirFace2U,NbTimesU,DirFace1V,DirFace2V,NbTimesV,Parameters = ParseParameters(
7951               DirFace1U,DirFace2U,NbTimesU,DirFace1V,DirFace2V,NbTimesV)
7952             anObj = self.BlocksOp.MakeMultiTransformation2D(Block, DirFace1U, DirFace2U, NbTimesU,
7953                                                             DirFace1V, DirFace2V, NbTimesV)
7954             RaiseIfFailed("MakeMultiTransformation2D", self.BlocksOp)
7955             anObj.SetParameters(Parameters)
7956             return anObj
7957
7958         ## Build all possible propagation groups.
7959         #  Propagation group is a set of all edges, opposite to one (main)
7960         #  edge of this group directly or through other opposite edges.
7961         #  Notion of Opposite Edge make sence only on quadrangle face.
7962         #  @param theShape Shape to build propagation groups on.
7963         #  @return List of GEOM.GEOM_Object, each of them is a propagation group.
7964         #
7965         #  @ref swig_Propagate "Example"
7966         def Propagate(self,theShape):
7967             """
7968             Build all possible propagation groups.
7969             Propagation group is a set of all edges, opposite to one (main)
7970             edge of this group directly or through other opposite edges.
7971             Notion of Opposite Edge make sence only on quadrangle face.
7972
7973             Parameters:
7974                 theShape Shape to build propagation groups on.
7975
7976             Returns:
7977                 List of GEOM.GEOM_Object, each of them is a propagation group.
7978             """
7979             # Example: see GEOM_TestOthers.py
7980             listChains = self.BlocksOp.Propagate(theShape)
7981             RaiseIfFailed("Propagate", self.BlocksOp)
7982             return listChains
7983
7984         # end of l3_blocks_op
7985         ## @}
7986
7987         ## @addtogroup l3_groups
7988         ## @{
7989
7990         ## Creates a new group which will store sub-shapes of theMainShape
7991         #  @param theMainShape is a GEOM object on which the group is selected
7992         #  @param theShapeType defines a shape type of the group (see GEOM::shape_type)
7993         #  @return a newly created GEOM group
7994         #
7995         #  @ref tui_working_with_groups_page "Example 1"
7996         #  \n @ref swig_CreateGroup "Example 2"
7997         def CreateGroup(self,theMainShape, theShapeType):
7998             """
7999             Creates a new group which will store sub-shapes of theMainShape
8000
8001             Parameters:
8002                theMainShape is a GEOM object on which the group is selected
8003                theShapeType defines a shape type of the group:"COMPOUND", "COMPSOLID",
8004                             "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX", "SHAPE".
8005
8006             Returns:
8007                a newly created GEOM group
8008
8009             Example of usage:
8010                 group = geompy.CreateGroup(Box, geompy.ShapeType["FACE"])
8011
8012             """
8013             # Example: see GEOM_TestOthers.py
8014             anObj = self.GroupOp.CreateGroup(theMainShape, theShapeType)
8015             RaiseIfFailed("CreateGroup", self.GroupOp)
8016             return anObj
8017
8018         ## Adds a sub-object with ID theSubShapeId to the group
8019         #  @param theGroup is a GEOM group to which the new sub-shape is added
8020         #  @param theSubShapeID is a sub-shape ID in the main object.
8021         #  \note Use method GetSubShapeID() to get an unique ID of the sub-shape
8022         #
8023         #  @ref tui_working_with_groups_page "Example"
8024         def AddObject(self,theGroup, theSubShapeID):
8025             """
8026             Adds a sub-object with ID theSubShapeId to the group
8027
8028             Parameters:
8029                 theGroup       is a GEOM group to which the new sub-shape is added
8030                 theSubShapeID  is a sub-shape ID in the main object.
8031
8032             Note:
8033                 Use method GetSubShapeID() to get an unique ID of the sub-shape
8034             """
8035             # Example: see GEOM_TestOthers.py
8036             self.GroupOp.AddObject(theGroup, theSubShapeID)
8037             if self.GroupOp.GetErrorCode() != "PAL_ELEMENT_ALREADY_PRESENT":
8038                 RaiseIfFailed("AddObject", self.GroupOp)
8039                 pass
8040             pass
8041
8042         ## Removes a sub-object with ID \a theSubShapeId from the group
8043         #  @param theGroup is a GEOM group from which the new sub-shape is removed
8044         #  @param theSubShapeID is a sub-shape ID in the main object.
8045         #  \note Use method GetSubShapeID() to get an unique ID of the sub-shape
8046         #
8047         #  @ref tui_working_with_groups_page "Example"
8048         def RemoveObject(self,theGroup, theSubShapeID):
8049             """
8050             Removes a sub-object with ID theSubShapeId from the group
8051
8052             Parameters:
8053                 theGroup is a GEOM group from which the new sub-shape is removed
8054                 theSubShapeID is a sub-shape ID in the main object.
8055
8056             Note:
8057                 Use method GetSubShapeID() to get an unique ID of the sub-shape
8058             """
8059             # Example: see GEOM_TestOthers.py
8060             self.GroupOp.RemoveObject(theGroup, theSubShapeID)
8061             RaiseIfFailed("RemoveObject", self.GroupOp)
8062             pass
8063
8064         ## Adds to the group all the given shapes. No errors, if some shapes are alredy included.
8065         #  @param theGroup is a GEOM group to which the new sub-shapes are added.
8066         #  @param theSubShapes is a list of sub-shapes to be added.
8067         #
8068         #  @ref tui_working_with_groups_page "Example"
8069         def UnionList (self,theGroup, theSubShapes):
8070             """
8071             Adds to the group all the given shapes. No errors, if some shapes are alredy included.
8072
8073             Parameters:
8074                 theGroup is a GEOM group to which the new sub-shapes are added.
8075                 theSubShapes is a list of sub-shapes to be added.
8076             """
8077             # Example: see GEOM_TestOthers.py
8078             self.GroupOp.UnionList(theGroup, theSubShapes)
8079             RaiseIfFailed("UnionList", self.GroupOp)
8080             pass
8081
8082         ## Adds to the group all the given shapes. No errors, if some shapes are alredy included.
8083         #  @param theGroup is a GEOM group to which the new sub-shapes are added.
8084         #  @param theSubShapes is a list of indices of sub-shapes to be added.
8085         #
8086         #  @ref swig_UnionIDs "Example"
8087         def UnionIDs(self,theGroup, theSubShapes):
8088             """
8089             Adds to the group all the given shapes. No errors, if some shapes are alredy included.
8090
8091             Parameters:
8092                 theGroup is a GEOM group to which the new sub-shapes are added.
8093                 theSubShapes is a list of indices of sub-shapes to be added.
8094             """
8095             # Example: see GEOM_TestOthers.py
8096             self.GroupOp.UnionIDs(theGroup, theSubShapes)
8097             RaiseIfFailed("UnionIDs", self.GroupOp)
8098             pass
8099
8100         ## Removes from the group all the given shapes. No errors, if some shapes are not included.
8101         #  @param theGroup is a GEOM group from which the sub-shapes are removed.
8102         #  @param theSubShapes is a list of sub-shapes to be removed.
8103         #
8104         #  @ref tui_working_with_groups_page "Example"
8105         def DifferenceList (self,theGroup, theSubShapes):
8106             """
8107             Removes from the group all the given shapes. No errors, if some shapes are not included.
8108
8109             Parameters:
8110                 theGroup is a GEOM group from which the sub-shapes are removed.
8111                 theSubShapes is a list of sub-shapes to be removed.
8112             """
8113             # Example: see GEOM_TestOthers.py
8114             self.GroupOp.DifferenceList(theGroup, theSubShapes)
8115             RaiseIfFailed("DifferenceList", self.GroupOp)
8116             pass
8117
8118         ## Removes from the group all the given shapes. No errors, if some shapes are not included.
8119         #  @param theGroup is a GEOM group from which the sub-shapes are removed.
8120         #  @param theSubShapes is a list of indices of sub-shapes to be removed.
8121         #
8122         #  @ref swig_DifferenceIDs "Example"
8123         def DifferenceIDs(self,theGroup, theSubShapes):
8124             """
8125             Removes from the group all the given shapes. No errors, if some shapes are not included.
8126
8127             Parameters:
8128                 theGroup is a GEOM group from which the sub-shapes are removed.
8129                 theSubShapes is a list of indices of sub-shapes to be removed.
8130             """
8131             # Example: see GEOM_TestOthers.py
8132             self.GroupOp.DifferenceIDs(theGroup, theSubShapes)
8133             RaiseIfFailed("DifferenceIDs", self.GroupOp)
8134             pass
8135
8136         ## Returns a list of sub-objects ID stored in the group
8137         #  @param theGroup is a GEOM group for which a list of IDs is requested
8138         #
8139         #  @ref swig_GetObjectIDs "Example"
8140         def GetObjectIDs(self,theGroup):
8141             """
8142             Returns a list of sub-objects ID stored in the group
8143
8144             Parameters:
8145                 theGroup is a GEOM group for which a list of IDs is requested
8146             """
8147             # Example: see GEOM_TestOthers.py
8148             ListIDs = self.GroupOp.GetObjects(theGroup)
8149             RaiseIfFailed("GetObjects", self.GroupOp)
8150             return ListIDs
8151
8152         ## Returns a type of sub-objects stored in the group
8153         #  @param theGroup is a GEOM group which type is returned.
8154         #
8155         #  @ref swig_GetType "Example"
8156         def GetType(self,theGroup):
8157             """
8158             Returns a type of sub-objects stored in the group
8159
8160             Parameters:
8161                 theGroup is a GEOM group which type is returned.
8162             """
8163             # Example: see GEOM_TestOthers.py
8164             aType = self.GroupOp.GetType(theGroup)
8165             RaiseIfFailed("GetType", self.GroupOp)
8166             return aType
8167
8168         ## Convert a type of geom object from id to string value
8169         #  @param theId is a GEOM obect type id.
8170         #  @return type of geom object (POINT, VECTOR, PLANE, LINE, TORUS, ... )
8171         #  @ref swig_GetType "Example"
8172         def ShapeIdToType(self, theId):
8173             """
8174             Convert a type of geom object from id to string value
8175
8176             Parameters:
8177                 theId is a GEOM obect type id.
8178
8179             Returns:
8180                 type of geom object (POINT, VECTOR, PLANE, LINE, TORUS, ... )
8181             """
8182             if theId == 0:
8183                 return "COPY"
8184             if theId == 1:
8185                 return "IMPORT"
8186             if theId == 2:
8187                 return "POINT"
8188             if theId == 3:
8189                 return "VECTOR"
8190             if theId == 4:
8191                 return "PLANE"
8192             if theId == 5:
8193                 return "LINE"
8194             if theId == 6:
8195                 return "TORUS"
8196             if theId == 7:
8197                 return "BOX"
8198             if theId == 8:
8199                 return "CYLINDER"
8200             if theId == 9:
8201                 return "CONE"
8202             if theId == 10:
8203                 return "SPHERE"
8204             if theId == 11:
8205                 return "PRISM"
8206             if theId == 12:
8207                 return "REVOLUTION"
8208             if theId == 13:
8209                 return "BOOLEAN"
8210             if theId == 14:
8211                 return "PARTITION"
8212             if theId == 15:
8213                 return "POLYLINE"
8214             if theId == 16:
8215                 return "CIRCLE"
8216             if theId == 17:
8217                 return "SPLINE"
8218             if theId == 18:
8219                 return "ELLIPSE"
8220             if theId == 19:
8221                 return "CIRC_ARC"
8222             if theId == 20:
8223                 return "FILLET"
8224             if theId == 21:
8225                 return "CHAMFER"
8226             if theId == 22:
8227                 return "EDGE"
8228             if theId == 23:
8229                 return "WIRE"
8230             if theId == 24:
8231                 return "FACE"
8232             if theId == 25:
8233                 return "SHELL"
8234             if theId == 26:
8235                 return "SOLID"
8236             if theId == 27:
8237                 return "COMPOUND"
8238             if theId == 28:
8239                 return "SUBSHAPE"
8240             if theId == 29:
8241                 return "PIPE"
8242             if theId == 30:
8243                 return "ARCHIMEDE"
8244             if theId == 31:
8245                 return "FILLING"
8246             if theId == 32:
8247                 return "EXPLODE"
8248             if theId == 33:
8249                 return "GLUED"
8250             if theId == 34:
8251                 return "SKETCHER"
8252             if theId == 35:
8253                 return "CDG"
8254             if theId == 36:
8255                 return "FREE_BOUNDS"
8256             if theId == 37:
8257                 return "GROUP"
8258             if theId == 38:
8259                 return "BLOCK"
8260             if theId == 39:
8261                 return "MARKER"
8262             if theId == 40:
8263                 return "THRUSECTIONS"
8264             if theId == 41:
8265                 return "COMPOUNDFILTER"
8266             if theId == 42:
8267                 return "SHAPES_ON_SHAPE"
8268             if theId == 43:
8269                 return "ELLIPSE_ARC"
8270             if theId == 44:
8271                 return "3DSKETCHER"
8272             if theId == 45:
8273                 return "FILLET_2D"
8274             if theId == 46:
8275                 return "FILLET_1D"
8276             if theId == 201:
8277                 return "PIPETSHAPE"
8278             return "Shape Id not exist."
8279
8280         ## Returns a main shape associated with the group
8281         #  @param theGroup is a GEOM group for which a main shape object is requested
8282         #  @return a GEOM object which is a main shape for theGroup
8283         #
8284         #  @ref swig_GetMainShape "Example"
8285         def GetMainShape(self,theGroup):
8286             """
8287             Returns a main shape associated with the group
8288
8289             Parameters:
8290                 theGroup is a GEOM group for which a main shape object is requested
8291
8292             Returns:
8293                 a GEOM object which is a main shape for theGroup
8294
8295             Example of usage: BoxCopy = geompy.GetMainShape(CreateGroup)
8296             """
8297             # Example: see GEOM_TestOthers.py
8298             anObj = self.GroupOp.GetMainShape(theGroup)
8299             RaiseIfFailed("GetMainShape", self.GroupOp)
8300             return anObj
8301
8302         ## Create group of edges of theShape, whose length is in range [min_length, max_length].
8303         #  If include_min/max == 0, edges with length == min/max_length will not be included in result.
8304         #  @param theShape given shape (see GEOM.GEOM_Object)
8305         #  @param min_length minimum length of edges of theShape
8306         #  @param max_length maximum length of edges of theShape
8307         #  @param include_max indicating if edges with length == max_length should be included in result, 1-yes, 0-no (default=1)
8308         #  @param include_min indicating if edges with length == min_length should be included in result, 1-yes, 0-no (default=1)
8309         #  @return a newly created GEOM group of edges
8310         #  @@ref swig_todo "Example"
8311         def GetEdgesByLength (self, theShape, min_length, max_length, include_min = 1, include_max = 1):
8312             """
8313             Create group of edges of theShape, whose length is in range [min_length, max_length].
8314             If include_min/max == 0, edges with length == min/max_length will not be included in result.
8315
8316             Parameters:
8317                 theShape given shape
8318                 min_length minimum length of edges of theShape
8319                 max_length maximum length of edges of theShape
8320                 include_max indicating if edges with length == max_length should be included in result, 1-yes, 0-no (default=1)
8321                 include_min indicating if edges with length == min_length should be included in result, 1-yes, 0-no (default=1)
8322
8323              Returns:
8324                 a newly created GEOM group of edges.
8325             """
8326             edges = self.SubShapeAll(theShape, ShapeType["EDGE"])
8327             edges_in_range = []
8328             for edge in edges:
8329                 Props = self.BasicProperties(edge)
8330                 if min_length <= Props[0] and Props[0] <= max_length:
8331                     if (not include_min) and (min_length == Props[0]):
8332                         skip = 1
8333                     else:
8334                         if (not include_max) and (Props[0] == max_length):
8335                             skip = 1
8336                         else:
8337                             edges_in_range.append(edge)
8338
8339             if len(edges_in_range) <= 0:
8340                 print "No edges found by given criteria"
8341                 return 0
8342
8343             group_edges = self.CreateGroup(theShape, ShapeType["EDGE"])
8344             self.UnionList(group_edges, edges_in_range)
8345
8346             return group_edges
8347
8348         ## Create group of edges of selected shape, whose length is in range [min_length, max_length].
8349         #  If include_min/max == 0, edges with length == min/max_length will not be included in result.
8350         #  @param min_length minimum length of edges of selected shape
8351         #  @param max_length maximum length of edges of selected shape
8352         #  @param include_max indicating if edges with length == max_length should be included in result, 1-yes, 0-no (default=1)
8353         #  @param include_min indicating if edges with length == min_length should be included in result, 1-yes, 0-no (default=1)
8354         #  @return a newly created GEOM group of edges
8355         #  @ref swig_todo "Example"
8356         def SelectEdges (self, min_length, max_length, include_min = 1, include_max = 1):
8357             """
8358             Create group of edges of selected shape, whose length is in range [min_length, max_length].
8359             If include_min/max == 0, edges with length == min/max_length will not be included in result.
8360
8361             Parameters:
8362                 min_length minimum length of edges of selected shape
8363                 max_length maximum length of edges of selected shape
8364                 include_max indicating if edges with length == max_length should be included in result, 1-yes, 0-no (default=1)
8365                 include_min indicating if edges with length == min_length should be included in result, 1-yes, 0-no (default=1)
8366
8367              Returns:
8368                 a newly created GEOM group of edges.
8369             """
8370             nb_selected = sg.SelectedCount()
8371             if nb_selected < 1:
8372                 print "Select a shape before calling this function, please."
8373                 return 0
8374             if nb_selected > 1:
8375                 print "Only one shape must be selected"
8376                 return 0
8377
8378             id_shape = sg.getSelected(0)
8379             shape = IDToObject( id_shape )
8380
8381             group_edges = self.GetEdgesByLength(shape, min_length, max_length, include_min, include_max)
8382
8383             left_str  = " < "
8384             right_str = " < "
8385             if include_min: left_str  = " <= "
8386             if include_max: right_str  = " <= "
8387
8388             self.addToStudyInFather(shape, group_edges, "Group of edges with " + `min_length`
8389                                     + left_str + "length" + right_str + `max_length`)
8390
8391             sg.updateObjBrowser(1)
8392
8393             return group_edges
8394
8395         # end of l3_groups
8396         ## @}
8397
8398         ## @addtogroup l4_advanced
8399         ## @{
8400
8401         ## Create a T-shape object with specified caracteristics for the main
8402         #  and the incident pipes (radius, width, half-length).
8403         #  The extremities of the main pipe are located on junctions points P1 and P2.
8404         #  The extremity of the incident pipe is located on junction point P3.
8405         #  If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8406         #  the main plane of the T-shape is XOY.
8407         #  @param theR1 Internal radius of main pipe
8408         #  @param theW1 Width of main pipe
8409         #  @param theL1 Half-length of main pipe
8410         #  @param theR2 Internal radius of incident pipe (R2 < R1)
8411         #  @param theW2 Width of incident pipe (R2+W2 < R1+W1)
8412         #  @param theL2 Half-length of incident pipe
8413         #  @param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8414         #  @param theP1 1st junction point of main pipe
8415         #  @param theP2 2nd junction point of main pipe
8416         #  @param theP3 Junction point of incident pipe
8417         #  @return List of GEOM.GEOM_Object, containing the created shape and propagation groups.
8418         #
8419         #  @ref tui_creation_pipetshape "Example"
8420         def MakePipeTShape(self, theR1, theW1, theL1, theR2, theW2, theL2, theHexMesh=True, theP1=None, theP2=None, theP3=None):
8421             """
8422             Create a T-shape object with specified caracteristics for the main
8423             and the incident pipes (radius, width, half-length).
8424             The extremities of the main pipe are located on junctions points P1 and P2.
8425             The extremity of the incident pipe is located on junction point P3.
8426             If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8427             the main plane of the T-shape is XOY.
8428
8429             Paremeters:
8430                 theR1 Internal radius of main pipe
8431                 theW1 Width of main pipe
8432                 theL1 Half-length of main pipe
8433                 theR2 Internal radius of incident pipe (R2 < R1)
8434                 theW2 Width of incident pipe (R2+W2 < R1+W1)
8435                 theL2 Half-length of incident pipe
8436                 theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8437                 theP1 1st junction point of main pipe
8438                 theP2 2nd junction point of main pipe
8439                 theP3 Junction point of incident pipe
8440
8441             Returns:
8442                 List of GEOM_Object, containing the created shape and propagation groups.
8443
8444             Example of usage:
8445                 # create PipeTShape object
8446                 pipetshape = geompy.MakePipeTShape(80.0, 20.0, 200.0, 50.0, 20.0, 200.0)
8447                 # create PipeTShape object with position
8448                 pipetshape_position = geompy.MakePipeTShape(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, True, P1, P2, P3)
8449             """
8450             theR1, theW1, theL1, theR2, theW2, theL2, Parameters = ParseParameters(theR1, theW1, theL1, theR2, theW2, theL2)
8451             if (theP1 and theP2 and theP3):
8452                 anObj = self.AdvOp.MakePipeTShapeWithPosition(theR1, theW1, theL1, theR2, theW2, theL2, theHexMesh, theP1, theP2, theP3)
8453             else:
8454                 anObj = self.AdvOp.MakePipeTShape(theR1, theW1, theL1, theR2, theW2, theL2, theHexMesh)
8455             RaiseIfFailed("MakePipeTShape", self.AdvOp)
8456             if Parameters: anObj[0].SetParameters(Parameters)
8457             return anObj
8458
8459         ## Create a T-shape object with chamfer and with specified caracteristics for the main
8460         #  and the incident pipes (radius, width, half-length). The chamfer is
8461         #  created on the junction of the pipes.
8462         #  The extremities of the main pipe are located on junctions points P1 and P2.
8463         #  The extremity of the incident pipe is located on junction point P3.
8464         #  If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8465         #  the main plane of the T-shape is XOY.
8466         #  @param theR1 Internal radius of main pipe
8467         #  @param theW1 Width of main pipe
8468         #  @param theL1 Half-length of main pipe
8469         #  @param theR2 Internal radius of incident pipe (R2 < R1)
8470         #  @param theW2 Width of incident pipe (R2+W2 < R1+W1)
8471         #  @param theL2 Half-length of incident pipe
8472         #  @param theH Height of the chamfer.
8473         #  @param theW Width of the chamfer.
8474         #  @param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8475         #  @param theP1 1st junction point of main pipe
8476         #  @param theP2 2nd junction point of main pipe
8477         #  @param theP3 Junction point of incident pipe
8478         #  @return List of GEOM.GEOM_Object, containing the created shape and propagation groups.
8479         #
8480         #  @ref tui_creation_pipetshape "Example"
8481         def MakePipeTShapeChamfer(self, theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, theHexMesh=True, theP1=None, theP2=None, theP3=None):
8482             """
8483             Create a T-shape object with chamfer and with specified caracteristics for the main
8484             and the incident pipes (radius, width, half-length). The chamfer is
8485             created on the junction of the pipes.
8486             The extremities of the main pipe are located on junctions points P1 and P2.
8487             The extremity of the incident pipe is located on junction point P3.
8488             If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8489             the main plane of the T-shape is XOY.
8490
8491             Paremeters:
8492                 theR1 Internal radius of main pipe
8493                 theW1 Width of main pipe
8494                 theL1 Half-length of main pipe
8495                 theR2 Internal radius of incident pipe (R2 < R1)
8496                 theW2 Width of incident pipe (R2+W2 < R1+W1)
8497                 theL2 Half-length of incident pipe
8498                 theH Height of the chamfer.
8499                 theW Width of the chamfer.
8500                 theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8501                 theP1 1st junction point of main pipe
8502                 theP2 2nd junction point of main pipe
8503                 theP3 Junction point of incident pipe
8504
8505             Returns:
8506                 List of GEOM_Object, containing the created shape and propagation groups.
8507
8508             Example of usage:
8509                 # create PipeTShape with chamfer object
8510                 pipetshapechamfer = geompy.MakePipeTShapeChamfer(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 20.0, 20.0)
8511                 # create PipeTShape with chamfer object with position
8512                 pipetshapechamfer_position = geompy.MakePipeTShapeChamfer(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 20.0, 20.0, True, P1, P2, P3)
8513             """
8514             theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, Parameters = ParseParameters(theR1, theW1, theL1, theR2, theW2, theL2, theH, theW)
8515             if (theP1 and theP2 and theP3):
8516               anObj = self.AdvOp.MakePipeTShapeChamferWithPosition(theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, theHexMesh, theP1, theP2, theP3)
8517             else:
8518               anObj = self.AdvOp.MakePipeTShapeChamfer(theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, theHexMesh)
8519             RaiseIfFailed("MakePipeTShapeChamfer", self.AdvOp)
8520             if Parameters: anObj[0].SetParameters(Parameters)
8521             return anObj
8522
8523         ## Create a T-shape object with fillet and with specified caracteristics for the main
8524         #  and the incident pipes (radius, width, half-length). The fillet is
8525         #  created on the junction of the pipes.
8526         #  The extremities of the main pipe are located on junctions points P1 and P2.
8527         #  The extremity of the incident pipe is located on junction point P3.
8528         #  If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8529         #  the main plane of the T-shape is XOY.
8530         #  @param theR1 Internal radius of main pipe
8531         #  @param theW1 Width of main pipe
8532         #  @param theL1 Half-length of main pipe
8533         #  @param theR2 Internal radius of incident pipe (R2 < R1)
8534         #  @param theW2 Width of incident pipe (R2+W2 < R1+W1)
8535         #  @param theL2 Half-length of incident pipe
8536         #  @param theRF Radius of curvature of fillet.
8537         #  @param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8538         #  @param theP1 1st junction point of main pipe
8539         #  @param theP2 2nd junction point of main pipe
8540         #  @param theP3 Junction point of incident pipe
8541         #  @return List of GEOM.GEOM_Object, containing the created shape and propagation groups.
8542         #
8543         #  @ref tui_creation_pipetshape "Example"
8544         def MakePipeTShapeFillet(self, theR1, theW1, theL1, theR2, theW2, theL2, theRF, theHexMesh=True, theP1=None, theP2=None, theP3=None):
8545             """
8546             Create a T-shape object with fillet and with specified caracteristics for the main
8547             and the incident pipes (radius, width, half-length). The fillet is
8548             created on the junction of the pipes.
8549             The extremities of the main pipe are located on junctions points P1 and P2.
8550             The extremity of the incident pipe is located on junction point P3.
8551
8552             Paremeters:
8553                 If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
8554                 the main plane of the T-shape is XOY.
8555                 theR1 Internal radius of main pipe
8556                 theW1 Width of main pipe
8557                 heL1 Half-length of main pipe
8558                 theR2 Internal radius of incident pipe (R2 < R1)
8559                 theW2 Width of incident pipe (R2+W2 < R1+W1)
8560                 theL2 Half-length of incident pipe
8561                 theRF Radius of curvature of fillet.
8562                 theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
8563                 theP1 1st junction point of main pipe
8564                 theP2 2nd junction point of main pipe
8565                 theP3 Junction point of incident pipe
8566
8567             Returns:
8568                 List of GEOM_Object, containing the created shape and propagation groups.
8569
8570             Example of usage:
8571                 # create PipeTShape with fillet object
8572                 pipetshapefillet = geompy.MakePipeTShapeFillet(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 5.0)
8573                 # create PipeTShape with fillet object with position
8574                 pipetshapefillet_position = geompy.MakePipeTShapeFillet(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 5.0, True, P1, P2, P3)
8575
8576             """
8577             theR1, theW1, theL1, theR2, theW2, theL2, theRF, Parameters = ParseParameters(theR1, theW1, theL1, theR2, theW2, theL2, theRF)
8578             if (theP1 and theP2 and theP3):
8579               anObj = self.AdvOp.MakePipeTShapeFilletWithPosition(theR1, theW1, theL1, theR2, theW2, theL2, theRF, theHexMesh, theP1, theP2, theP3)
8580             else:
8581               anObj = self.AdvOp.MakePipeTShapeFillet(theR1, theW1, theL1, theR2, theW2, theL2, theRF, theHexMesh)
8582             RaiseIfFailed("MakePipeTShapeFillet", self.AdvOp)
8583             if Parameters: anObj[0].SetParameters(Parameters)
8584             return anObj
8585
8586         ## This function allows creating a disk already divided into blocks. It
8587         #  can be used to create divided pipes for later meshing in hexaedra.
8588         #  @param theR Radius of the disk
8589         #  @param theOrientation Orientation of the plane on which the disk will be built
8590         #         1 = XOY, 2 = OYZ, 3 = OZX
8591         #  @param thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
8592         #  @return New GEOM_Object, containing the created shape.
8593         #
8594         #  @ref tui_creation_divideddisk "Example"
8595         def MakeDividedDisk(self, theR, theOrientation, thePattern ):
8596             theR, Parameters = ParseParameters(theR)
8597             anObj = self.AdvOp.MakeDividedDisk(theR, 67.0, theOrientation, thePattern)
8598             RaiseIfFailed("MakeDividedDisk", self.AdvOp)
8599             if Parameters: anObj.SetParameters(Parameters)
8600             return anObj
8601
8602         ## This function allows creating a disk already divided into blocks. It
8603         #  can be used to create divided pipes for later meshing in hexaedra.
8604         #  @param theCenter Center of the disk
8605         #  @param theVector Normal vector to the plane of the created disk
8606         #  @param theRadius Radius of the disk
8607         #  @param thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
8608         #  @return New GEOM_Object, containing the created shape.
8609         #
8610         #  @ref tui_creation_divideddisk "Example"
8611         def MakeDividedDiskPntVecR(self, theCenter, theVector, theRadius, thePattern):
8612             theRadius, Parameters = ParseParameters(theRadius)
8613             anObj = self.AdvOp.MakeDividedDiskPntVecR(theCenter, theVector, theRadius, 67.0, thePattern)
8614             RaiseIfFailed("MakeDividedDiskPntVecR", self.AdvOp)
8615             if Parameters: anObj.SetParameters(Parameters)
8616             return anObj
8617
8618         ## Builds a cylinder prepared for hexa meshes
8619         #  @param theR Radius of the cylinder
8620         #  @param theH Height of the cylinder
8621         #  @param thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
8622         #  @return New GEOM_Object, containing the created shape.
8623         #
8624         #  @ref tui_creation_dividedcylinder "Example"
8625         def MakeDividedCylinder(self, theR, theH, thePattern):
8626             theR, theH, Parameters = ParseParameters(theR, theH)
8627             anObj = self.AdvOp.MakeDividedCylinder(theR, theH, thePattern)
8628             RaiseIfFailed("MakeDividedCylinder", self.AdvOp)
8629             if Parameters: anObj.SetParameters(Parameters)
8630             return anObj
8631
8632         #@@ insert new functions before this line @@ do not remove this line @@#
8633
8634         # end of l4_advanced
8635         ## @}
8636
8637         ## Create a copy of the given object
8638         #
8639         #  @param theOriginal geometry object for copy
8640         #  @return unique object identifier
8641         #  @ingroup l1_geompy_auxiliary
8642         #  @ref swig_MakeCopy "Example"
8643         def MakeCopy(self,theOriginal):
8644             """
8645             Create a copy of the given object
8646
8647             Paremeters:
8648                 theOriginal geometry object for copy
8649
8650             Returns:
8651                 unique object identifier
8652
8653             Example of usage: Copy = geompy.MakeCopy(Box)
8654             """
8655             # Example: see GEOM_TestAll.py
8656             anObj = self.InsertOp.MakeCopy(theOriginal)
8657             RaiseIfFailed("MakeCopy", self.InsertOp)
8658             return anObj
8659
8660         ## Add Path to load python scripts from
8661         #  @param Path a path to load python scripts from
8662         #  @ingroup l1_geompy_auxiliary
8663         def addPath(self,Path):
8664             """
8665             Add Path to load python scripts from
8666
8667             Parameters:
8668                 Path a path to load python scripts from
8669             """
8670             if (sys.path.count(Path) < 1):
8671                 sys.path.append(Path)
8672                 pass
8673             pass
8674
8675         ## Load marker texture from the file
8676         #  @param Path a path to the texture file
8677         #  @return unique texture identifier
8678         #  @ingroup l1_geompy_auxiliary
8679         def LoadTexture(self, Path):
8680             """
8681             Load marker texture from the file
8682
8683             Parameters:
8684                 Path a path to the texture file
8685
8686             Returns:
8687                 unique texture identifier
8688             """
8689             # Example: see GEOM_TestAll.py
8690             ID = self.InsertOp.LoadTexture(Path)
8691             RaiseIfFailed("LoadTexture", self.InsertOp)
8692             return ID
8693
8694         ## Get entry of the object
8695         #  @param obj geometry object
8696         #  @return unique object identifier
8697         #  @ingroup l1_geompy_auxiliary
8698         def getObjectID(self, obj):
8699             """
8700             Get entry of the object
8701
8702             Parameters:
8703                 obj geometry object
8704
8705             Returns:
8706                 unique object identifier
8707             """
8708             ID = ""
8709             entry = salome.ObjectToID(obj)
8710             if entry is not None:
8711                 lst = entry.split(":")
8712                 if len(lst) > 0:
8713                     ID = lst[-1] # -1 means last item in the list
8714                     return "GEOM_" + ID
8715             return ID
8716
8717
8718
8719         ## Add marker texture. @a Width and @a Height parameters
8720         #  specify width and height of the texture in pixels.
8721         #  If @a RowData is @c True, @a Texture parameter should represent texture data
8722         #  packed into the byte array. If @a RowData is @c False (default), @a Texture
8723         #  parameter should be unpacked string, in which '1' symbols represent opaque
8724         #  pixels and '0' represent transparent pixels of the texture bitmap.
8725         #
8726         #  @param Width texture width in pixels
8727         #  @param Height texture height in pixels
8728         #  @param Texture texture data
8729         #  @param RowData if @c True, @a Texture data are packed in the byte stream
8730         #  @return unique texture identifier
8731         #  @ingroup l1_geompy_auxiliary
8732         def AddTexture(self, Width, Height, Texture, RowData=False):
8733             """
8734             Add marker texture. Width and Height parameters
8735             specify width and height of the texture in pixels.
8736             If RowData is True, Texture parameter should represent texture data
8737             packed into the byte array. If RowData is False (default), Texture
8738             parameter should be unpacked string, in which '1' symbols represent opaque
8739             pixels and '0' represent transparent pixels of the texture bitmap.
8740
8741             Parameters:
8742                 Width texture width in pixels
8743                 Height texture height in pixels
8744                 Texture texture data
8745                 RowData if True, Texture data are packed in the byte stream
8746
8747             Returns:
8748                 return unique texture identifier
8749             """
8750             if not RowData: Texture = PackData(Texture)
8751             ID = self.InsertOp.AddTexture(Width, Height, Texture)
8752             RaiseIfFailed("AddTexture", self.InsertOp)
8753             return ID
8754
8755 import omniORB
8756 #Register the new proxy for GEOM_Gen
8757 omniORB.registerObjref(GEOM._objref_GEOM_Gen._NP_RepositoryId, geompyDC)