src/GEOM_SWIG/gsketcher.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2016  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, or (at your option) any later version.
   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   : gsketcher.py
  21 #  Author : Julia DOROVSKIKH, Open CASCADE S.A.S.
  22 #  Module : GEOM_SWIG
  23
  24 ## @defgroup sketcher gsketcher - Wrapper to help the creation of simple sketches
  25 #  @{
  26 #  @details
  27 #  This module provides the user with a simple python API
  28 #  to realize various sketches from the GEOM text user interface.
  29 #  @n Example:
  30 #  @code
  31 #  import GEOM
  32 #  from salome.geom import geomBuilder
  33 #  geompy = geomBuilder.New(salome.myStudy)
  34 #
  35 #  # create a wire for sketcher
  36 #  geomObj_1 = geompy.MakeMarker(0, 0, 0, 1, 0, 0, 0, 1, 0)
  37 #
  38 #  # Create the sketch
  39 #  sk = geompy.Sketcher2D()
  40 #  sk.addPoint(0.000000, 0.000000)
  41 #  sk.addSegmentAbsolute(50.000000, 50.000000)
  42 #  sk.addSegmentPerpY(0.000000)
  43 #  sk.addArcAbsolute(0.000000, 0.000000)
  44 #  sk.close()
  45 #  Sketch_1 = sk.wire(geomObj_1)
  46 #
  47 #  # add objects in the study
  48 #  geompy.addToStudy( Sketch_1, 'Sketch_1' )
  49 #
  50 #  # update object browser
  51 #  salome.sg.updateObjBrowser(1)
  52 #  @endcode
  53 #  @n Additionnal examples can be found as unit tests in the source code.
  54 #  @}
  55
  56 """
  57     \namespace geompy
  58     \brief 2D and 3D Sketcher interfaces
  59 """
  60
  61 # This method is used by 3D Sketcher functionality
  62 def printVar (var):
  63     if isinstance(var, str):
  64         return "\'%s\'"%var
  65     else:
  66         return "%.7f"%var
  67
  68 ## An interface to build a 3D Sketcher step-by-step.
  69 #  Use geompy.Sketcher3D() method to obtain an instance of this class.
  70 #
  71 #  @ref tui_3dsketcher_page "Example"
  72 #  @ingroup sketcher
  73 class Sketcher3D:
  74     """
  75     3D sketcher interface.
  76
  77     Example of usage:
  78         sk = geompy.Sketcher3D()
  79         sk.addPointsAbsolute(0,0,0, 70,0,0)
  80         sk.addPointsRelative(0, 0, 130)
  81         sk.addPointRadiusAnglesRelative(50, 0, 100, 'OXY')
  82         sk.addPointRadiusAnglesRelative(30, 80, 130, 'OXZ')
  83         sk.close()
  84         a3D_Sketcher_1 = sk.wire()
  85     """
  86
  87     def __init__(self, geompyD):
  88         self.geompyD = geompyD
  89         self.myCommand = "3DSketcher"
  90         pass
  91
  92     ## Add one or more points, sequentially connected with straight segments.
  93     #  Coordinates are considered as absolute.
  94     #  If the first point of sketcher is not yet defined, the first point
  95     #  from the listCoords will become the first sketcher point.
  96     #  @param listCoords X1, Y1, Z1, X2, Y2, Z2, ... Coordinates of points
  97     def addPointsAbsolute (self, *listCoords):
  98         """
  99         Add one or more points, sequentially connected with straight segments.
 100         Coordinates are considered as absolute.
 101         If the first point of sketcher is not yet defined, the first point
 102         from the listCoords will become the first sketcher point.
 103
 104         Parameters:
 105             X1, Y1, Z1, X2, Y2, Z2, ... Coordinates of points
 106
 107         Example of usage:
 108             sk = geompy.Sketcher3D()
 109             sk.addPointsAbsolute(0,0,0, 70,0,0)
 110             a3D_Sketcher_1 = sk.wire()
 111         """
 112         ii = 1
 113         for cc in listCoords:
 114             if ii == 1:
 115                 self.myCommand = self.myCommand + ":TT"
 116             self.myCommand = self.myCommand + " %s"%printVar(cc)
 117             if ii == 3:
 118                 ii = 1
 119             else:
 120                 ii = ii + 1
 121         pass
 122
 123     ## Add one or more points, sequentially connected with straight segments.
 124     #  Coordinates are considered relative to the previous point.
 125     #  If the first point of sketcher is not yet defined, the
 126     #  origin (0, 0, 0) will become the first sketcher point.
 127     #  @param listCoords X1, Y1, Z1, X2, Y2, Z2, ... Coordinates of points
 128     def addPointsRelative (self, *listCoords):
 129         """
 130         Add one or more points, sequentially connected with straight segments.
 131         Coordinates are considered relative to the previous point.
 132         If the first point of sketcher is not yet defined, the
 133         origin (0, 0, 0) will become the first sketcher point.
 134
 135         Parameters:
 136             X1, Y1, Z1, X2, Y2, Z2, ... Relative coordinates of points
 137
 138         Example of usage:
 139             sk = geompy.Sketcher3D()
 140             sk.addPointsRelative(0,0,130, 70,0,-130)
 141             a3D_Sketcher_1 = sk.wire()
 142         """
 143         ii = 1
 144         for cc in listCoords:
 145             if ii == 1:
 146                 self.myCommand = self.myCommand + ":T"
 147             self.myCommand = self.myCommand + " %s"%printVar(cc)
 148             if ii == 3:
 149                 ii = 1
 150             else:
 151                 ii = ii + 1
 152         pass
 153
 154     ## Add one straight segment, defined by two angles and length.
 155     #  If the first point of sketcher is not yet defined, the
 156     #  origin (0, 0, 0) will become the first sketcher point.
 157     #  The radius and angles coordinates are defined
 158     #  in a local coordinate system which origin is the last point of the sketch
 159     #
 160     #  @param length length of the segment
 161     #  @param angle1 angle in a plane, defined by the \a axes
 162     #  @param angle2 angle from the plane, defined by the \a axes
 163     #  @param axes can be: "OXY", "OYZ" or "OXZ"
 164     def addPointRadiusAnglesRelative (self, length, angle1, angle2, axes="OXY"):
 165         """
 166         Add one straight segment, defined by two angles and length.
 167         If the first point of sketcher is not yet defined, the
 168         origin (0, 0, 0) will become the first sketcher point.
 169
 170         Parameters:
 171             length length of the segment
 172             angle1 angle in a plane, defined by the \a axes
 173             angle2 angle from the plane, defined by the \a axes
 174             axes can be: "OXY", "OYZ" or "OXZ"
 175
 176         Example of usage:
 177             sk = geompy.Sketcher3D()
 178             sk.addPointRadiusAnglesRelative(100, 50, 0, "OXY")
 179             a3D_Sketcher_1 = sk.wire()
 180         """
 181         self.myCommand = self.myCommand + ":%s"%axes+"SR"+" %s %s %s" % (printVar(angle1), printVar(angle2), printVar(length))
 182         pass
 183
 184     ## Add one straight segment, defined by two angles and radius.
 185     #  If the first point of sketcher is not yet defined, the
 186     #  origin (0, 0, 0) will become the first sketcher point.
 187     #  The radius and angles coordinates are defined
 188     #  in a coordinate system which origin is the global coordinate system origin
 189     #
 190     #  @param radius distance to the coordinate system origin
 191     #  @param angle1 angle in a plane, defined by the \a axes
 192     #  @param angle2 angle from the plane, defined by the \a axes
 193     #  @param axes can be: "OXY", "OYZ" or "OXZ"
 194     def addPointRadiusAnglesAbsolute (self, radius, angle1, angle2, axes="OXY"):
 195         """
 196         Add one straight segment, defined by two angles and length.
 197         If the first point of sketcher is not yet defined, the
 198         origin (0, 0, 0) will become the first sketcher point.
 199
 200         Parameters:
 201             radius distance to the coordinate system origin
 202             angle1 angle in a plane, defined by the \a axes
 203             angle2 angle from the plane, defined by the \a axes
 204             axes can be: "OXY", "OYZ" or "OXZ"
 205
 206         Example of usage:
 207             sk = geompy.Sketcher3D()
 208             sk.addPointRadiusAnglesAbsolute(100, 50, 0, "OXY")
 209             a3D_Sketcher_1 = sk.wire()
 210         """
 211         self.myCommand = self.myCommand + ":%s"%axes+"SA"+" %s %s %s" % (printVar(angle1), printVar(angle2), printVar(radius))
 212         pass
 213
 214     ## Add one straight segment, defined by an angle, a height and a radius.
 215     #  If the first point of sketcher is not yet defined, the
 216     #  origin (0, 0, 0) will become the first sketcher point.
 217     #  The radius height and angle coordinates are defined
 218     #  in a local coordinate system which origin is the last point of the sketch
 219     #
 220     #  @param axes can be: "OXY", "OYZ" or "OXZ"
 221     #  @param angle angle in a plane, defined by the \a axes
 222     #  @param height height from the plane, defined by the \a axes
 223     #  @param length distance to the coordinate system origin
 224     def addPointRadiusAngleHRelative (self, length, angle, height, axes="OXY"):
 225         """
 226         Add one straight segment, defined by two angles and length.
 227         If the first point of sketcher is not yet defined, the
 228         origin (0, 0, 0) will become the first sketcher point.
 229
 230         Parameters:
 231             radius distance to the coordinate system origin
 232             angle  angle in a plane, defined by the \a axes
 233             height height from the plane, defined by the \a axes
 234             axes can be: "OXY", "OYZ" or "OXZ"
 235
 236         Example of usage:
 237             sk = geompy.Sketcher3D()
 238             sk.addPointRadiusAngleHRelative(100, 50, 40, "OXY")
 239             a3D_Sketcher_1 = sk.wire()
 240         """
 241         self.myCommand = self.myCommand + ":%s"%axes+"CR"+" %s %s %s" % (printVar(angle), printVar(height), printVar(length))
 242         pass
 243
 244     ## Add one straight segment, defined by an angle, a height and a radius.
 245     #  If the first point of sketcher is not yet defined, the
 246     #  origin (0, 0, 0) will become the first sketcher point.
 247     #  The radius height and angle coordinates are defined
 248     #  in a coordinate system which origin is the global coordinate system origin
 249     #
 250     #  @param radius distance to the coordinate system origin
 251     #  @param angle angle in a plane, defined by the \a axes
 252     #  @param height height from the plane, defined by the \a axes
 253     #  @param axes can be: "OXY", "OYZ" or "OXZ"
 254     def addPointRadiusAngleHAbsolute (self, radius, angle, height, axes="OXY"):
 255         """
 256         Add one straight segment, defined by two angles and length.
 257         If the first point of sketcher is not yet defined, the
 258         origin (0, 0, 0) will become the first sketcher point.
 259
 260         Parameters:
 261             axes can be: "OXY", "OYZ" or "OXZ"
 262             angle1 angle in a plane, defined by the \a axes
 263             height height from the plane, defined by the \a axes
 264             radius distance to the coordinate system origin
 265
 266         Example of usage:
 267             sk = geompy.Sketcher3D()
 268             sk.addPointRadiusAngleHAbsolute( 100, 50, 40, "OXY")
 269             a3D_Sketcher_1 = sk.wire()
 270         """
 271         self.myCommand = self.myCommand + ":%s"%axes+"CA"+" %s %s %s" % (printVar(angle), printVar(height), printVar(radius))
 272         pass
 273
 274     ## Set to close the wire
 275     def close (self):
 276         """
 277         Set to close the wire
 278
 279         Example of usage:
 280             sk = geompy.Sketcher3D()
 281             sk.addPointsRelative(0,0,130, 70,0,-130)
 282             sk.close()
 283             a3D_Sketcher_1 = sk.wire()
 284         """
 285         self.myCommand = self.myCommand + ":WW"
 286         pass
 287
 288     ## Obtain the sketcher result.
 289     #  @param theName Object name; when specified, this parameter is used
 290     #         for result publication in the study. Otherwise, if automatic
 291     #         publication is switched on, default value is used for result name.
 292     #
 293     #  @return New GEOM_Object, containing the created wire
 294     def wire (self, theName=None):
 295         """
 296         Obtain the sketcher result.
 297
 298         Parameters:
 299             theName Object name; when specified, this parameter is used
 300                     for result publication in the study. Otherwise, if automatic
 301                     publication is switched on, default value is used for result name.
 302
 303         Returns:
 304             New GEOM_Object, containing the created wire.
 305
 306         Example of usage:
 307             sk = geompy.Sketcher3D()
 308             sk.addPointsRelative(0,0,130, 70,0,-130)
 309             a3D_Sketcher_1 = sk.wire()
 310         """
 311         from salome.geom.geomBuilder import ParseSketcherCommand, RaiseIfFailed
 312         Command,Parameters = ParseSketcherCommand(self.myCommand)
 313         wire = self.geompyD.CurvesOp.Make3DSketcherCommand(Command)
 314         self.myCommand = "3DSketcher"
 315         RaiseIfFailed("Sketcher3D", self.geompyD.CurvesOp)
 316         wire.SetParameters(Parameters)
 317         self.geompyD._autoPublish(wire, theName, "wire")
 318         return wire
 319
 320 ##  An interface to build a 2D Sketcher step-by-step.
 321 #  Use geompy.Sketcher2D() method to obtain an instance of this class.
 322 #  @ingroup sketcher
 323 class Sketcher2D:
 324     """
 325     2D sketcher interface.
 326
 327     Example of usage:
 328         sk = geompy.Sketcher2D()
 329         sk.addPoint(20, 20)
 330         sk.addSegmentRelative(15, 70)
 331         sk.addSegmentPerpY(50)
 332         sk.addArcRadiusRelative(25, 15, 14.5, 0)
 333         sk.addArcCenterAbsolute(1, 1, 50, 50, 0, 0)
 334         sk.addArcDirectionRadiusLength(20, 20, 101, 162.13)
 335         sk.close()
 336         Sketch_1 = sk.wire(geomObj_1)
 337     """
 338     def __init__(self, geompyD):
 339         self.geompyD = geompyD
 340         self.myCommand = "Sketcher"
 341         self.closed = False
 342         pass
 343
 344     ## Add one point.
 345     #  Used to set the starting point
 346     #
 347     #  @param x, y - Coordinates of point
 348     def addPoint (self, x, y):
 349         """
 350         Add one point.
 351         Used to set the starting point
 352
 353         Parameters:
 354             x, y - Coordinates of point
 355
 356         Example of usage:
 357             sk = geompy.Sketcher2D()
 358             sk.addPoint(20, 20)
 359             Sketcher_1 = sk.wire(geomObj_1)
 360         """
 361         self.myCommand = self.myCommand + ":F %s %s" % (printVar(x), printVar(y))
 362         pass
 363
 364     ## Add angle.
 365     #  Used to set the angle for further building
 366     #
 367     #  @param angle - angle in a plane
 368     def addAngle (self, angle):
 369         """
 370         Add angle.
 371         Used to set the angle for further building
 372
 373         Parameters:
 374             angle - angle in a plane
 375
 376         Example of usage:
 377             sk = geompy.Sketcher2D()
 378             sk.addAngle(70)
 379             Sketcher_1 = sk.wire(geomObj_1)
 380         """
 381         self.myCommand = self.myCommand + ":RR %s" % (printVar(angle))
 382         pass
 383
 384     #  Commands for creation of segment
 385
 386     ## Add segment, which sequentially connects the previous point
 387     #  with a point lying on a line parallel to the axis Ox and the value x = param x.
 388     #  The current point will be the previous value to the coordinate y and
 389     #  new value to the coordinate x.
 390     #  Coordinate is considered relative to the previous point.
 391     #
 392     #  @param x - Coordinate of point on axis Ox
 393     def addSegmentParalX(self, x):
 394         """
 395         Add segment, which sequentially connects the previous point
 396         with a point lying on a line parallel to the axis Ox and the value x = param x.
 397         The current point will be the previous value to the coordinate y and
 398         new value to the coordinate x.
 399         Coordinate is considered relative to the previous point.
 400
 401         Parameters:
 402             x - Coordinate of point on axis Ox
 403
 404         Example of usage:
 405             sk = geompy.Sketcher2D()
 406             sk.addSegmentParalX(40)
 407             Sketcher_1 = sk.wire(geomObj_1)
 408         """
 409         self.myCommand = self.myCommand + ":X %s" % (printVar(x))
 410         pass
 411
 412     ## Add segment, which sequentially connects the previous point
 413     #  with a point lying on a line parallel to the axis Ox and the value x = 0
 414     #  The current point will be the previous value to the coordinate y.
 415     def addSegmentParalXToZero(self):
 416         """
 417         Add segment, which sequentially connects the previous point
 418         with a point lying on a line parallel to the axis Ox and the value x = 0
 419         The current point will be the previous value to the coordinate y.
 420
 421         Example of usage:
 422             sk = geompy.Sketcher2D()
 423             sk.addSegmentParalXToZero()
 424             Sketcher_1 = sk.wire(geomObj_1)
 425         """
 426         self.myCommand = self.myCommand + ":XX"
 427         pass
 428
 429     ## Add segment, which sequentially connects the previous point
 430     #  with a point lying on a line parallel to the axis Oy and the value y = param y.
 431     #  The current point will be the previous value to the coordinate x and
 432     #  new value to the coordinate y.
 433     #  Coordinate is considered relative to the previous point.
 434     #
 435     #  @param y - Coordinate of point on axis Oy
 436     def addSegmentParalY(self, y):
 437         """
 438         Add segment, which sequentially connects the previous point
 439         with a point lying on a line parallel to the axis Oy and the value y = param y.
 440         The current point will be the previous value to the coordinate x and
 441         new value to the coordinate y.
 442         Coordinate is considered relative to the previous point.
 443
 444         Parameters:
 445             y - Coordinate of point on axis Oy
 446
 447         Example of usage:
 448             sk = geompy.Sketcher2D()
 449             sk.addSegmentParalY(80)
 450             Sketcher_1 = sk.wire(geomObj_1)
 451         """
 452         self.myCommand = self.myCommand + ":Y %s" % (printVar(y))
 453         pass
 454
 455     ## Add segment, which sequentially connects the previous point
 456     #  with a point lying on a line parallel to the axis Ox and the value x = 0
 457     #  The current point will be the previous value to the coordinate y.
 458     def addSegmentParalYToZero(self):
 459         """
 460         Add segment, which sequentially connects the previous point
 461         with a point lying on a line parallel to the axis Oy and the value y = 0
 462         The current point will be the previous value to the coordinate x.
 463
 464         Example of usage:
 465             sk = geompy.Sketcher2D()
 466             sk.addSegmentParalYToZero()
 467             Sketcher_1 = sk.wire(geomObj_1)
 468         """
 469         self.myCommand = self.myCommand + ":YY"
 470         pass
 471
 472     ## Add segment, which sequentially connects the given point with previous point
 473     #
 474     #  Coordinates are considered as absolute.
 475     #  @param x, y - Coordinates of point
 476     def addSegmentAbsolute (self, x, y):
 477         """
 478         Add segment, which sequentially connects the starting point with the given point
 479         Coordinates are considered as absolute.
 480
 481         Parameters:
 482             x, y - Coordinates of point
 483
 484         Example of usage:
 485             sk = geompy.Sketcher2D()
 486             sk.addSegmentAbsolute(30, 50)
 487             Sketcher_1 = sk.wire(geomObj_1)
 488         """
 489         self.myCommand = self.myCommand + ":TT %s %s" % (printVar(x), printVar(y))
 490         pass
 491
 492     ## Add segment, which sequentially connects the given point with previous point
 493     #  Coordinates are considered relative to the previous point.
 494     #  If the first point of sketcher is not yet defined, the
 495     #  origin (0, 0) will become the first sketcher point.
 496     #
 497     #  @param dx, dy - Coordinates of point relative a previous point
 498     def addSegmentRelative (self, dx, dy):
 499         """
 500         Add segment, which sequentially connects the given point with previous point
 501         Coordinates are considered relative to the previous point.
 502         If the first point of sketcher is not yet defined, the
 503         origin (0, 0) will become the first sketcher point.
 504
 505         Parameters:
 506             dx, dy - Coordinates of point relative a previous point
 507
 508         Example of usage:
 509             sk = geompy.Sketcher2D()
 510             sk.addSegmentRelative(60, 10)
 511             Sketcher_1 = sk.wire(geomObj_1)
 512         """
 513         self.myCommand = self.myCommand + ":T %s %s" % (printVar(dx), printVar(dy))
 514         pass
 515
 516     ## Add one straight segment, defined by angle and length.
 517     #  If the first point of sketcher is not yet defined, the
 518     #  origin (0, 0) will become the first sketcher point.
 519     #  The angle and length coordinates are defined
 520     #  in a local coordinate system which origin is the last point of the sketch
 521     #
 522     #  @param angle - angle in a plane
 523     #  @param length - length of the segment
 524     def addSegmentAngleLength (self, angle, length ):
 525         """
 526         Add one straight segment, defined by angle and length.
 527         If the first point of sketcher is not yet defined, the
 528         origin (0, 0) will become the first sketcher point.
 529         The radius and angles coordinates are defined
 530         in a local coordinate system which origin is the last point of the sketch
 531
 532         Parameters:
 533             angle - angle in a plane
 534             length - length of the segment
 535
 536         Example of usage:
 537             sk = geompy.Sketcher2D()
 538             sk.addSegmentAngleLength(10, 30)
 539             Sketcher_1 = sk.wire(geomObj_1)
 540         """
 541         self.myCommand = self.myCommand + ":R %s:L %s" % (printVar(angle), printVar(length))
 542         pass
 543
 544     ## Add one straight segment, defined by angle and intersect straight x= param x.
 545     #  If the first point of sketcher is not yet defined, the
 546     #  origin (0, 0) will become the first sketcher point.
 547     #  The angle and point's coordinates are defined
 548     #  in a local coordinate system which origin is the last point of the sketch
 549     #
 550     #  @param angle - angle in a plane
 551     #  @param x - value on the axis Ox
 552     def addSegmentAngleX (self, angle, x ):
 553         """
 554         Add one straight segment, defined by angle and intersect straight x= param x.
 555         If the first point of sketcher is not yet defined, the
 556         origin (0, 0) will become the first sketcher point.
 557         The angle and point's coordinates are defined
 558         in a local coordinate system which origin is the last point of the sketch
 559
 560         Parameters:
 561             angle - angle in a plane
 562             x - value on the axis Ox
 563
 564         Example of usage:
 565             sk = geompy.Sketcher2D()
 566             sk.addSegmentAngleX(25, 90)
 567             Sketcher_1 = sk.wire(geomObj_1)
 568         """
 569         self.myCommand = self.myCommand + ":R %s:IX %s" % (printVar(angle), printVar(x))
 570         pass
 571
 572     ## Add one straight segment, defined by angle and intersect straight y= param y.
 573     #  If the first point of sketcher is not yet defined, the
 574     #  origin (0, 0) will become the first sketcher point.
 575     #  The angle and point's coordinates are defined
 576     #  in a local coordinate system which origin is the last point of the sketch
 577     #
 578     #  @param angle - angle in a plane
 579     #  @param y - value on the axis Oy
 580     def addSegmentAngleY (self, angle, y ):
 581         """
 582         Add one straight segment, defined by angle and intersect straight y= param y.
 583         If the first point of sketcher is not yet defined, the
 584         origin (0, 0) will become the first sketcher point.
 585         The angle and point's coordinates are defined
 586         in a local coordinate system which origin is the last point of the sketch
 587
 588         Parameters:
 589             angle - angle in a plane
 590             y - value on the axis Oy
 591
 592         Example of usage:
 593             sk = geompy.Sketcher2D()
 594             sk.addSegmentAngleY(40, 0)
 595             Sketcher_1 = sk.wire(geomObj_1)
 596         """
 597         self.myCommand = self.myCommand + ":R %s:IY %s" % (printVar(angle), printVar(y))
 598         pass
 599
 600
 601     ## Add one straight segment, defined by perpendicular(angle=90) and length.
 602     #  If the first point of sketcher is not yet defined, the
 603     #  origin (0, 0) will become the first sketcher point.
 604     #  The length coordinates are defined
 605     #  in a local coordinate system which origin is the last point of the sketch
 606     #
 607     #  @param length - length of the segment
 608     def addSegmentPerpLength (self, length ):
 609         """
 610         Add one straight segment, defined by perpendicular and length.
 611         If the first point of sketcher is not yet defined, the
 612         origin (0, 0) will become the first sketcher point.
 613         The length coordinates are defined
 614         in a local coordinate system which origin is the last point of the sketch
 615
 616         Parameters:
 617             length - length of the segment
 618
 619         Example of usage:
 620             sk = geompy.Sketcher2D()
 621             sk.addSegmentPerpLength(100)
 622             Sketcher_1 = sk.wire(geomObj_1)
 623         """
 624         self.myCommand = self.myCommand + ":R 90:L %s" % (printVar(length))
 625         pass
 626
 627     ## Add one straight segment, defined by perpendicular(angle=90) and intersect straight x= param x.
 628     #  If the first point of sketcher is not yet defined, the
 629     #  origin (0, 0) will become the first sketcher point.
 630     #  The point's coordinates are defined
 631     #  in a local coordinate system which origin is the last point of the sketch
 632     #
 633     #  @param x - value on the axis Ox
 634     def addSegmentPerpX (self, x ):
 635         """
 636         Add one straight segment, defined by perpendicular(angle=90) and intersect straight x= param x.
 637         If the first point of sketcher is not yet defined, the
 638         origin (0, 0) will become the first sketcher point.
 639         The point's coordinates are defined
 640         in a local coordinate system which origin is the last point of the sketch
 641
 642         Parameters:
 643             x - value on the axis Ox
 644
 645         Example of usage:
 646             sk = geompy.Sketcher2D()
 647             sk.addSegmentPerpX(30)
 648             Sketcher_1 = sk.wire(geomObj_1)
 649         """
 650         self.myCommand = self.myCommand + ":R 90:IX %s" % (printVar(x))
 651         pass
 652
 653     ## Add one straight segment, defined by perpendicular(angle=90) and intersect straight y= param y.
 654     #  If the first point of sketcher is not yet defined, the
 655     #  origin (0, 0) will become the first sketcher point.
 656     #  The point's coordinates are defined
 657     #  in a local coordinate system which origin is the last point of the sketch
 658     #
 659     #  @param y - value on the axis Oy
 660     def addSegmentPerpY (self, y ):
 661         """
 662         Add one straight segment, defined by perpendicular(angle=90) and intersect straight y= param y.
 663         If the first point of sketcher is not yet defined, the
 664         origin (0, 0) will become the first sketcher point.
 665         The point's coordinates are defined
 666         in a local coordinate system which origin is the last point of the sketch
 667
 668         Parameters:
 669             y - value on the axis Oy
 670
 671         Example of usage:
 672             sk = geompy.Sketcher2D()
 673             sk.addSegmentPerpY(10)
 674             Sketcher_1 = sk.wire(geomObj_1)
 675         """
 676         self.myCommand = self.myCommand + ":R 90:IY %s" % (printVar(y))
 677         pass
 678
 679
 680     ## Add one straight segment, defined by previous direction and length.
 681     #  If the first point of sketcher is not yet defined, the
 682     #  origin (0, 0) will become the first sketcher point.
 683     #  The length coordinates are defined
 684     #  in a local coordinate system which origin is the last point of the sketch
 685     #
 686     #  @param length - length of the segment
 687     def addSegmentLength (self, length ):
 688         """
 689         Add one straight segment, defined by previous direction and length.
 690         If the first point of sketcher is not yet defined, the
 691         origin (0, 0) will become the first sketcher point.
 692         The length coordinates are defined
 693         in a local coordinate system which origin is the last point of the sketch
 694
 695         Parameters:
 696             length - length of the segment
 697
 698         Example of usage:
 699             sk = geompy.Sketcher2D()
 700             sk.addSegmentLength(100)
 701             Sketcher_1 = sk.wire(geomObj_1)
 702         """
 703         self.myCommand = self.myCommand + ":L %s" % (printVar(length))
 704         pass
 705
 706     ## Add one straight segment, defined by previous direction and intersect straight x= param x.
 707     #  If the first point of sketcher is not yet defined, the
 708     #  origin (0, 0) will become the first sketcher point.
 709     #  The point's coordinates are defined
 710     #  in a local coordinate system which origin is the last point of the sketch
 711     #
 712     #  @param x - value on the axis Ox
 713     def addSegmentX (self, x ):
 714         """
 715         Add one straight segment, defined by previous direction and intersect straight x= param x.
 716         If the first point of sketcher is not yet defined, the
 717         origin (0, 0) will become the first sketcher point.
 718         The point's coordinates are defined
 719         in a local coordinate system which origin is the last point of the sketch
 720
 721         Parameters:
 722             x - value on the axis Ox
 723
 724         Example of usage:
 725             sk = geompy.Sketcher2D()
 726             sk.addSegmentX(30)
 727             Sketcher_1 = sk.wire(geomObj_1)
 728         """
 729         self.myCommand = self.myCommand + ":IX %s" % (printVar(x))
 730         pass
 731
 732     ## Add one straight segment, defined by previous direction and intersect straight y= param y.
 733     #  If the first point of sketcher is not yet defined, the
 734     #  origin (0, 0) will become the first sketcher point.
 735     #  The point's coordinates are defined
 736     #  in a local coordinate system which origin is the last point of the sketch
 737     #
 738     #  @param y - value on the axis Oy
 739     def addSegmentY (self, y ):
 740         """
 741         Add one straight segment, defined by previous direction and intersect straight y= param y.
 742         If the first point of sketcher is not yet defined, the
 743         origin (0, 0) will become the first sketcher point.
 744         The point's coordinates are defined
 745         in a local coordinate system which origin is the last point of the sketch
 746
 747         Parameters:
 748             y - value on the axis Oy
 749
 750         Example of usage:
 751             sk = geompy.Sketcher2D()
 752             sk.addSegmentY(10)
 753             Sketcher_1 = sk.wire(geomObj_1)
 754         """
 755         self.myCommand = self.myCommand + ":IY %s" % (printVar(y))
 756         pass
 757
 758
 759     ## Add one straight segment, defined by direction and length.
 760     #  If the first point of sketcher is not yet defined, the
 761     #  origin (0, 0) will become the first sketcher point.
 762     #  The direction and length coordinates are defined
 763     #  in a local coordinate system which origin is the last point of the sketch
 764     #
 765     #  @param dx, dy - direction of the segment
 766     #  @param length - length of the segment
 767     def addSegmentDirectionLength (self, dx, dy, length ):
 768         """
 769         Add one straight segment, defined by direction and length.
 770         If the first point of sketcher is not yet defined, the
 771         origin (0, 0) will become the first sketcher point.
 772         The direction and length coordinates are defined
 773         in a local coordinate system which origin is the last point of the sketch
 774
 775         Parameters:
 776             dx, dy - direction of the segment
 777             length - length of the segment
 778
 779         Example of usage:
 780             sk = geompy.Sketcher2D()
 781             sk.addSegmentDirectionLength(20, 40, 30)
 782             Sketcher_1 = sk.wire(geomObj_1)
 783         """
 784         self.myCommand = self.myCommand + ":D %s %s:L %s" % (printVar(dx), printVar(dy), printVar(length))
 785         pass
 786
 787     ## Add one straight segment, defined by direction and intersect straight x= param x.
 788     #  If the first point of sketcher is not yet defined, the
 789     #  origin (0, 0) will become the first sketcher point.
 790     #  The direction and point's coordinates are defined
 791     #  in a local coordinate system which origin is the last point of the sketch
 792     #
 793     #  @param dx, dy - direction of the segment
 794     #  @param x - value on the axis Ox
 795     def addSegmentDirectionX (self, dx, dy, x ):
 796         """
 797         Add one straight segment, defined by direction and intersect straight x= param x.
 798         If the first point of sketcher is not yet defined, the
 799         origin (0, 0) will become the first sketcher point.
 800         The direction and point's coordinates are defined
 801         in a local coordinate system which origin is the last point of the sketch
 802
 803         Parameters:
 804             dx, dy - direction of the segment
 805             x - value on the axis Ox
 806
 807         Example of usage:
 808             sk = geompy.Sketcher2D()
 809             sk.addSegmentDirectionX(10, -40, 20)
 810             Sketcher_1 = sk.wire(geomObj_1)
 811         """
 812         self.myCommand = self.myCommand + ":D %s %s:IX %s" % (printVar(dx), printVar(dy), printVar(x))
 813         pass
 814
 815     ## Add one straight segment, defined by direction and intersect straight y= param y.
 816     #  If the first point of sketcher is not yet defined, the
 817     #  origin (0, 0) will become the first sketcher point.
 818     #  The direction and point's coordinates are defined
 819     #  in a local coordinate system which origin is the last point of the sketch
 820     #
 821     #  @param dx, dy - direction of the segment
 822     #  @param y - value on the axis Oy
 823     def addSegmentDirectionY (self, dx, dy, y ):
 824         """
 825         Add one straight segment, defined by direction and intersect straight y= param y.
 826         If the first point of sketcher is not yet defined, the
 827         origin (0, 0) will become the first sketcher point.
 828         The direction and point's coordinates are defined
 829         in a local coordinate system which origin is the last point of the sketch
 830
 831         Parameters:
 832             dx, dy - direction of the segment
 833             y - value on the axis Oy
 834
 835         Example of usage:
 836             sk = geompy.Sketcher2D()
 837             sk.addSegmentDirectionY(-10, -50, 20)
 838             Sketcher_1 = sk.wire(geomObj_1)
 839         """
 840         self.myCommand = self.myCommand + ":D %s %s:IY %s" % (printVar(dx), printVar(dy), printVar(y))
 841         pass
 842
 843     #  Commands for creation of arc
 844
 845     ## Add arc, which connects the given point with previous point
 846     #  Coordinates are considered as absolute.
 847     #  If the first point of sketcher is not yet defined, the
 848     #  origin (0, 0) will become the first sketcher point.
 849     #
 850     #  @param x, y - Coordinates of second point of arc
 851     def addArcAbsolute (self, x, y ):
 852         """
 853         Add arc, which connects the given point with previous point
 854         Coordinates are considered as absolute.
 855         If the first point of sketcher is not yet defined, the
 856         origin (0, 0) will become the first sketcher point.
 857
 858         Parameters:
 859             param x, y - Coordinates of second point of arc
 860
 861         Example of usage:
 862             sk = geompy.Sketcher2D()
 863             sk.addArcAbsolute(50, 10)
 864             Sketcher_1 = sk.wire(geomObj_1)
 865         """
 866         self.myCommand = self.myCommand + ":AA %s %s" % (printVar(x), printVar(y))
 867         pass
 868
 869     ## Add arc, which connects the given point with previous point
 870     #  Coordinates are considered relative to the previous point.
 871     #
 872     #  @param dx, dy - Coordinates of second point of arc relative to the previous point
 873     def addArcRelative (self, dx, dy ):
 874         """
 875         Add arc, which connects the given point with previous point
 876         Coordinates are considered relative to the previous point.
 877
 878         Parameters:
 879             param dx, dy - Coordinates of second point of arc
 880
 881         Example of usage:
 882             sk = geompy.Sketcher2D()
 883             sk.addArcRelative(50, 10)
 884             Sketcher_1 = sk.wire(geomObj_1)
 885         """
 886         self.myCommand = self.myCommand + ":A %s %s" % (printVar(dx), printVar(dy))
 887         pass
 888
 889     ## Add arc, defined by radius and coordinates of next point.
 890     #  Coordinates are considered as absolute.
 891     #  If the first point of sketcher is not yet defined, the
 892     #  origin (0, 0) will become the first sketcher point.
 893     #
 894     #  @param x, y - Coordinates of second point of arc
 895     #  @param radius - radius of arc
 896     #  @param flag - is 0 or 2
 897     #                if 0 the drawn arc is the one of lower angle (<Pi)
 898     #                if 2 the drawn arc is the one of greater angle (>Pi)
 899     def addArcRadiusAbsolute (self, x, y, radius, flag ):
 900         """
 901         Add arc, defined by radius and coordinates of next point.
 902         Coordinates are considered as absolute.
 903         If the first point of sketcher is not yet defined, the
 904         origin (0, 0) will become the first sketcher point.
 905
 906         Parameters:
 907             param x, y - Coordinates of second point of arc
 908             param radius - radius of arc
 909             param flag - is 0 or 2
 910                          if 0 the drawn arc is the one of lower angle (<Pi)
 911                          if 2 the drawn arc is the one of greater angle (>Pi)
 912
 913         Example of usage:
 914             sk = geompy.Sketcher2D()
 915             sk.addArcRadiusAbsolute(50, 10, 20, 0)
 916             Sketcher_1 = sk.wire(geomObj_1)
 917         """
 918         self.myCommand = self.myCommand + ":UU %s %s %s %s" % (printVar(x), printVar(y), printVar(radius), printVar(flag))
 919         pass
 920
 921     ## Add arc, defined by radius and coordinates of next point.
 922     #  Coordinates are considered relative to the previous point.
 923     #
 924     #  @param dx, dy - Coordinates of second point of arc
 925     #  @param radius - radius of arc
 926     #  @param flag - is 0 or 2
 927     #                if 0 the drawn arc is the one of lower angle (<Pi)
 928     #                if 2 the drawn arc is the one of greater angle (>Pi)
 929     def addArcRadiusRelative (self, dx, dy, radius, flag ):
 930         """
 931         Add arc, defined by radius and coordinates of next point.
 932         Coordinates are considered relative to the previous point.
 933
 934         Parameters:
 935             param dx, dy - Coordinates of second point of arc
 936             param radius - radius of arc
 937             param flag - is 0 or 2
 938                          if 0 the drawn arc is the one of lower angle (<Pi)
 939                          if 2 the drawn arc is the one of greater angle (>Pi)
 940
 941         Example of usage:
 942             sk = geompy.Sketcher2D()
 943             sk.addArcRadiusRelative(-30, -15, 20, 2)
 944             Sketcher_1 = sk.wire(geomObj_1)
 945         """
 946         self.myCommand = self.myCommand + ":U %s %s %s %s" % (printVar(dx), printVar(dy), printVar(radius), printVar(flag))
 947         pass
 948
 949     ## Add arc, defined by coordinates of next point and coordinates of center.
 950     #  Coordinates are considered as absolute.
 951     #  If the first point of sketcher is not yet defined, the
 952     #  origin (0, 0) will become the first sketcher point.
 953     #
 954     #  @param x, y - Coordinates of second point of arc
 955     #  @param xc, yc - Coordinates of center
 956     #  @param flag1 - (reverse) is 0 or 2
 957     #                if 0 the drawn arc is the one of lower angle (<Pi)
 958     #                if 2 the drawn arc is the one of greater angle (>Pi)
 959     #  @param flag2 - (control tolerance) is 0 or 1
 960     #                if 0 the specified end point can be at a distance of the arc
 961     def addArcCenterAbsolute (self, x, y, xc, yc, flag1, flag2 ):
 962         """
 963         Add arc, defined by coordinates of next point and coordinates of center.
 964         Coordinates are considered as absolute.
 965         If the first point of sketcher is not yet defined, the
 966         origin (0, 0) will become the first sketcher point.
 967
 968         Parameters:
 969             param x, y - Coordinates of second point of arc
 970             param xc, yc - Coordinates of center
 971             param flag1 - is 0 or 2
 972                          if 0 the drawn arc is the one of lower angle (<Pi)
 973                          if 2 the drawn arc is the one of greater angle (>Pi)
 974             param flag2 - (control tolerance) is 0 or 1
 975                          if 0 the specified end point can be at a distance of the arc
 976
 977         Example of usage:
 978             sk = geompy.Sketcher2D()
 979             sk.addArcCenterAbsolute(-30, -15, 20, 10, 0, 0)
 980             Sketcher_1 = sk.wire(geomObj_1)
 981         """
 982         self.myCommand = self.myCommand + ":EE %s %s %s %s %s %s" % (printVar(xc), printVar(yc), printVar(x), printVar(y),
 983                                                                      printVar(flag1), printVar(flag2))
 984         pass
 985
 986     ## Add arc, defined by coordinates of next point and coordinates of center.
 987     #  Coordinates are considered relative to the previous point.
 988     #
 989     #  @param dx, dy - Coordinates of second point of arc
 990     #  @param xc, yc - Coordinates of center
 991     #  @param flag1 - (reverse) is 0 or 2
 992     #                if 0 the drawn arc is the one of lower angle (<Pi)
 993     #                if 2 the drawn arc is the one of greater angle (>Pi)
 994     #  @param flag2 - (control tolerance) is 0 or 1
 995     #                if 0 the specified end point can be at a distance of the arc
 996     def addArcCenterRelative (self, dx, dy, xc, yc, flag1, flag2 ):
 997         """
 998         Add arc, defined by coordinates of next point and coordinates of center.
 999         Coordinates are considered relative to the previous point.
1000
1001         Parameters:
1002             param dx, dy - Coordinates of second point of arc
1003             param xc, yc - Coordinates of center
1004             param flag1 - is 0 or 2
1005                          if 0 the drawn arc is the one of lower angle (<Pi)
1006                          if 2 the drawn arc is the one of greater angle (>Pi)
1007             param flag2 - (control tolerance) is 0 or 1
1008                          if 0 the specified end point can be at a distance of the arc
1009
1010         Example of usage:
1011             sk = geompy.Sketcher2D()
1012             sk.addArcCenterRelative(-30, -15, 20, 10, 2, 1)
1013             Sketcher_1 = sk.wire(geomObj_1)
1014         """
1015         self.myCommand = self.myCommand + ":E %s %s %s %s %s %s" % (printVar(xc), printVar(yc), printVar(dx), printVar(dy),
1016                                                                     printVar(flag1), printVar(flag2))
1017         pass
1018
1019     ## Add arc, defined by angle, radius and length.
1020     #  If the first point of sketcher is not yet defined, the
1021     #  origin (0, 0) will become the first sketcher point.
1022     #
1023     #  @param angle - angle in a plane
1024     #  @param radius - radius of the arc
1025     #  @param length - length of the arc
1026     def addArcAngleRadiusLength (self, angle, radius, length ):
1027         """
1028         Add arc, defined by angle, radius and length.
1029         If the first point of sketcher is not yet defined, the
1030         origin (0, 0) will become the first sketcher point.
1031
1032         Parameters:
1033             param angle - angle in a plane
1034             param radius - radius of the arc
1035             param length - length of the arc
1036
1037         Example of usage:
1038             sk = geompy.Sketcher2D()
1039             sk.addArcAngleRadiusLength(30, 15, 40)
1040             Sketcher_1 = sk.wire(geomObj_1)
1041         """
1042         self.myCommand = self.myCommand + ":R %s:C %s %s" % (printVar(angle), printVar(radius), printVar(length))
1043         pass
1044
1045     ## Add arc, defined by perpendicular(angle=90), radius and length.
1046     #  If the first point of sketcher is not yet defined, the
1047     #  origin (0, 0) will become the first sketcher point.
1048     #
1049     #  @param radius - radius of the arc
1050     #  @param length - length of the arc
1051     def addArcPerpRadiusLength (self, radius, length ):
1052         """
1053         Add arc, defined by perpendicular(angle=90), radius and length.
1054         If the first point of sketcher is not yet defined, the
1055         origin (0, 0) will become the first sketcher point.
1056
1057         Parameters:
1058             param radius - radius of the arc
1059             param length - length of the arc
1060
1061         Example of usage:
1062             sk = geompy.Sketcher2D()
1063             sk.addArcPerpRadiusLength(15, 40)
1064             Sketcher_1 = sk.wire(geomObj_1)
1065         """
1066         self.myCommand = self.myCommand + ":R 90:C %s %s" % (printVar(radius), printVar(length))
1067         pass
1068
1069     ## Add arc, defined by previous direction, radius and length.
1070     #  If the first point of sketcher is not yet defined, the
1071     #  origin (0, 0) will become the first sketcher point.
1072     #
1073     #  @param radius - radius of the arc
1074     #  @param length - length of the arc
1075     def addArcRadiusLength (self, radius, length ):
1076         """
1077         Add arc, defined by previous direction, radius and length.
1078         If the first point of sketcher is not yet defined, the
1079         origin (0, 0) will become the first sketcher point.
1080
1081         Parameters:
1082             param radius - radius of the arc
1083             param length - length of the arc
1084
1085         Example of usage:
1086             sk = geompy.Sketcher2D()
1087             sk.addArcRadiusLength(15, 40)
1088             Sketcher_1 = sk.wire(geomObj_1)
1089         """
1090         self.myCommand = self.myCommand + ":C %s %s" % (printVar(radius), printVar(length))
1091         pass
1092
1093     ## Add arc, defined by direction, radius and length.
1094     #  If the first point of sketcher is not yet defined, the
1095     #  origin (0, 0) will become the first sketcher point.
1096     #
1097     #  @param dx, dy - direction of the arc
1098     #  @param radius - radius of the arc
1099     #  @param length - length of the arc
1100     def addArcDirectionRadiusLength (self, dx, dy, radius, length ):
1101         """
1102         Add arc, defined by direction, radius and length.
1103         If the first point of sketcher is not yet defined, the
1104         origin (0, 0) will become the first sketcher point.
1105
1106         Parameters:
1107             param dx, dy - direction of the arc
1108             param radius - radius of the arc
1109             param length - length of the arc
1110
1111         Example of usage:
1112             sk = geompy.Sketcher2D()
1113             sk.addArcDirectionRadiusLength(-50, 40, 20, 3.5)
1114             Sketcher_1 = sk.wire(geomObj_1)
1115         """
1116         self.myCommand = self.myCommand + ":D %s %s:C %s %s" % (printVar(dx), printVar(dy), printVar(radius), printVar(length))
1117         pass
1118
1119     ## Set to close the wire
1120     def close (self):
1121         """
1122         Set to close the wire
1123
1124         Example of usage:
1125             sk = geompy.Sketcher2D()
1126             sk.addPoint(15, 85.6)
1127             sk.close()
1128             Sketcher_1 = sk.wire(geomObj_1)
1129         """
1130         self.closed = True
1131         pass
1132
1133     ## Obtain the sketcher result as a wire.
1134     #
1135     #  @param WorkingPlane - current Working Plane used for this 2DSketcher
1136     #  @param theName Object name; when specified, this parameter is used
1137     #         for result publication in the study. Otherwise, if automatic
1138     #         publication is switched on, default value is used for result name.
1139     #
1140     #  @return New GEOM_Object, containing the created wire
1141     def wire (self, WorkingPlane=[0, 0, 0, 0, 0, 1, 1, 0, 0], theName=None):
1142         """
1143         Obtain the sketcher result as a wire.
1144
1145         Parameters:
1146             theName Object name; when specified, this parameter is used
1147                     for result publication in the study. Otherwise, if automatic
1148                     publication is switched on, default value is used for result name
1149             param WorkingPlane - current Working Plane used for this 2DSketcher
1150
1151         Returns:
1152             New GEOM_Object, containing the created wire.
1153
1154         Example of usage:
1155             sk = geompy.Sketcher2D()
1156             sk.addPoint(30, 70)
1157             a3D_Sketcher_1 = sk.wire(geomObj_1)
1158         """
1159
1160         if self.closed:
1161             self.myCommand = self.myCommand + ":WW"
1162
1163         from salome.geom.geomBuilder import ParseSketcherCommand, RaiseIfFailed
1164         Command,Parameters = ParseSketcherCommand(self.myCommand)
1165
1166         import GEOM
1167         if isinstance(WorkingPlane, list): wire = self.geompyD.CurvesOp.MakeSketcher(Command, WorkingPlane)
1168         if isinstance(WorkingPlane, GEOM._objref_GEOM_Object): wire = self.geompyD.CurvesOp.MakeSketcherOnPlane(Command, WorkingPlane)
1169
1170         self.myCommand = "Sketcher"
1171         RaiseIfFailed("Sketcher", self.geompyD.CurvesOp)
1172         wire.SetParameters(Parameters)
1173         self.geompyD._autoPublish(wire, theName, "wire")
1174         return wire
1175
1176     ## Obtain the sketcher result as a face.
1177     #
1178     #  @param WorkingPlane - current Working Plane used for this 2DSketcher
1179     #  @param theName Object name; when specified, this parameter is used
1180     #         for result publication in the study. Otherwise, if automatic
1181     #         publication is switched on, default value is used for result name.
1182     #
1183     #  @return New GEOM_Object, containing the created face
1184     def face (self, WorkingPlane=[0, 0, 0, 0, 0, 1, 1, 0, 0], theName=None):
1185         """
1186         Obtain the sketcher result as a face.
1187
1188         Parameters:
1189             theName Object name; when specified, this parameter is used
1190                     for result publication in the study. Otherwise, if automatic
1191                     publication is switched on, default value is used for result name
1192             param WorkingPlane - current Working Plane used for this 2DSketcher
1193
1194         Returns:
1195             New GEOM_Object, containing the created face.
1196
1197         Example of usage:
1198             sk = geompy.Sketcher2D()
1199             sk.addPoint(0, 0)
1200             sk.addSegment(100, 0)
1201             sk.addSegment(100, 100)
1202             sk.addSegment(0, 100)
1203             sk.close()
1204             a3D_Sketcher_1 = sk.face(geomObj_1)
1205         """
1206
1207         if self.closed:
1208             self.myCommand = self.myCommand + ":WF"
1209         else:
1210             raise RuntimeError, "Sketcher2D.close() : can't build face on unclosed wire"
1211
1212         from salome.geom.geomBuilder import ParseSketcherCommand, RaiseIfFailed
1213         Command,Parameters = ParseSketcherCommand(self.myCommand)
1214
1215         import GEOM
1216         if isinstance(WorkingPlane, list): face = self.geompyD.CurvesOp.MakeSketcher(Command, WorkingPlane)
1217         if isinstance(WorkingPlane, GEOM._objref_GEOM_Object): face = self.geompyD.CurvesOp.MakeSketcherOnPlane(Command, WorkingPlane)
1218
1219         self.myCommand = "Sketcher"
1220         RaiseIfFailed("Sketcher", self.geompyD.CurvesOp)
1221         face.SetParameters(Parameters)
1222         self.geompyD._autoPublish(face, theName, "face")
1223         return face
1224
1225 ## An interface to build a 2D polyline step-by-step. The polyline can contain
1226 #  several sections. Each section represents a list of 2d points. As well it
1227 #  has a name, curve type, either polyline or interpolation (BSpline curve) and
1228 #  Closed flag.
1229 #  Use geompy.Polyline2D() method to obtain an instance of this class.
1230 #  @ingroup sketcher
1231 class Polyline2D:
1232     """
1233     An interface to build a 2D polyline step-by-step. The polyline can contain
1234     several sections. Each section represents a list of 2d points. As well it
1235     has a name, curve type, either polyline or interpolation (BSpline curve) and
1236     Closed flag.
1237     Use geompy.Polyline2D() method to obtain an instance of this class.
1238
1239     Example of usage:
1240         pl = geompy.Polyline2D()
1241         pl.addSection("section 1", GEOM.Polyline, True, [0, 0, 10, 0, 10, 10])
1242         pl.addSection("section 2", GEOM.Interpolation, False)
1243         pl.addPoints([20, 0, 30, 0, 30, 10])
1244         resultObj = pl.result(WorkingPlane)
1245     """
1246
1247     def __init__(self, geompyD):
1248         self.geompyD      = geompyD
1249         self.myNameList   = []
1250         self.myTypeList   = []
1251         self.myClosedList = []
1252         self.myCoordsList = []
1253         pass
1254
1255     ## Add a new section to the polyline.
1256     #
1257     #  @param theName the name
1258     #  @param theType the type. It can have either CORBA enumeration type
1259     #         GEOM.curve_type or a value of type long. Possible input values
1260     #         are: GEOM.Polyline(0) and GEOM.Interpolation(2).
1261     #  @param theClosed True for closed section; False otherwise
1262     #  @param thePoints the list of 2D points coordinates in the form:
1263     #         [x1, y1, x2, y2, ..., xN, yN] for N points.
1264     def addSection(self, theName, theType, theClosed, thePoints = None):
1265         """
1266         Add a new section to the polyline.
1267
1268         Parameters:
1269             theName the name
1270             theType the type. It can have either CORBA enumeration type
1271                     GEOM.curve_type or a value of type long. Possible input
1272                     values are: GEOM.Polyline(0) and GEOM.Interpolation(2).
1273             theClosed True for closed section; False otherwise
1274             thePoints the list of 2D points coordinates in the form:
1275                       [x1, y1, x2, y2, ..., xN, yN] for N points.
1276
1277         Example of usage:
1278             pl = geompy.Polyline2D()
1279             pl.addSection("section 1", GEOM.Polyline, True, [0, 0, 10, 0, 10, 10])
1280             resultObj = pl.result(WorkingPlane)
1281         """
1282         from salome.geom.geomBuilder import EnumToLong
1283         self.myNameList.append(theName)
1284         self.myTypeList.append(EnumToLong(theType))
1285         self.myClosedList.append(theClosed)
1286         if thePoints is None:
1287             self.myCoordsList.append([])
1288         else:
1289             self.myCoordsList.append(thePoints)
1290         pass
1291
1292     ## Add a points to the last added section of the polyline. If there are
1293     #  no sections in the polyline it does nothing.
1294     #
1295     #  @param thePoints the list of 2D points coordinates in the form:
1296     #         [x1, y1, x2, y2, ..., xN, yN] for N points.
1297     def addPoints(self, thePoints):
1298         """
1299         Add a points to the last added section of the polyline. If there are
1300         no sections in the polyline it does nothing.
1301
1302         Parameters:
1303             thePoints the list of 2D points coordinates in the form:
1304                       [x1, y1, x2, y2, ..., xN, yN] for N points.
1305
1306         Example of usage:
1307             pl = geompy.Polyline2D()
1308             pl.addSection("section 1", GEOM.Polyline, True)
1309             pl.addPoints([0, 0, 10, 0, 10, 10])
1310             pl.addPoints([20, 0, 30, 0, 30, 10])
1311             resultObj = pl.result(WorkingPlane)
1312         """
1313         if self.myNameList:
1314             self.myCoordsList[-1].extend(thePoints)
1315         pass
1316
1317     ## Obtain the 2D polyline result as a wire or a compound of wires in case
1318     #  of several sections defined.
1319     #
1320     #  @param theWorkingPlane - current Working Plane used for this 2D polyline
1321     #  @param theName Object name; when specified, this parameter is used
1322     #         for result publication in the study. Otherwise, if automatic
1323     #         publication is switched on, default value is used for result name.
1324     #
1325     #  @return New GEOM_Object, containing the created shape.
1326     def result(self, theWorkingPlane=[0, 0, 0, 0, 0, 1, 1, 0, 0], theName=None):
1327         """
1328         Obtain the 2D polyline result as a wire or a compound of wires in case
1329         of several sections defined.
1330
1331         Parameters:
1332             theWorkingPlane current Working Plane used for this 2D polyline
1333             theName Object name; when specified, this parameter is used
1334                     for result publication in the study. Otherwise, if automatic
1335                     publication is switched on, default value is used for result name.
1336
1337         Returns:
1338             New GEOM_Object, containing the created shape.
1339
1340         Example of usage:
1341             pl = geompy.Polyline2D()
1342             pl.addSection("section 1", GEOM.Polyline, True, [0, 0, 10, 0, 10, 10])
1343             pl.addSection("section 2", GEOM.Interpolation, False)
1344             pl.addPoints([20, 0, 30, 0, 30, 10])
1345             resultObj = pl.result(WorkingPlane)
1346         """
1347         from salome.geom.geomBuilder import RaiseIfFailed
1348         import GEOM
1349         if isinstance(theWorkingPlane, list):
1350             aResult = self.geompyD.CurvesOp.MakePolyline2D(
1351                          self.myCoordsList, self.myNameList, self.myTypeList,
1352                          self.myClosedList, theWorkingPlane)
1353         if isinstance(theWorkingPlane, GEOM._objref_GEOM_Object):
1354             aResult = self.geompyD.CurvesOp.MakePolyline2DOnPlane(
1355                         self.myCoordsList, self.myNameList, self.myTypeList,
1356                         self.myClosedList, theWorkingPlane)
1357
1358         self.myNameList   = []
1359         self.myTypeList   = []
1360         self.myClosedList = []
1361         self.myCoordsList = []
1362         RaiseIfFailed("Polyline2D.result", self.geompyD.CurvesOp)
1363         self.geompyD._autoPublish(aResult, theName, "polyline")
1364
1365         return aResult