mirror of
https://git.salome-platform.org/gitpub/modules/geom.git
synced 2025-01-05 22:30:34 +05:00
1356 lines
54 KiB
Python
1356 lines
54 KiB
Python
# -*- coding: iso-8859-1 -*-
|
|
# Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
|
|
#
|
|
# This library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Lesser General Public
|
|
# License as published by the Free Software Foundation; either
|
|
# version 2.1 of the License, or (at your option) any later version.
|
|
#
|
|
# This library is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with this library; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
#
|
|
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
|
|
#
|
|
# File : gsketcher.py
|
|
# Author : Julia DOROVSKIKH, Open CASCADE S.A.S.
|
|
# Module : GEOM_SWIG
|
|
|
|
## @defgroup sketcher gsketcher - Wrapper to help the creation of simple sketches
|
|
# @{
|
|
# @details
|
|
# This module provides the user with a simple python API
|
|
# to realize various sketches from the GEOM text user interface.
|
|
# @n Example:
|
|
# @code
|
|
# import GEOM
|
|
# from salome.geom import geomBuilder
|
|
# geompy = geomBuilder.New(salome.myStudy)
|
|
#
|
|
# # create a wire for sketcher
|
|
# geomObj_1 = geompy.MakeMarker(0, 0, 0, 1, 0, 0, 0, 1, 0)
|
|
#
|
|
# # Create the sketch
|
|
# sk = geompy.Sketcher2D()
|
|
# sk.addPoint(0.000000, 0.000000)
|
|
# sk.addSegmentAbsolute(50.000000, 50.000000)
|
|
# sk.addSegmentPerpY(0.000000)
|
|
# sk.addArcAbsolute(0.000000, 0.000000)
|
|
# sk.close()
|
|
# Sketch_1 = sk.wire(geomObj_1)
|
|
#
|
|
# # add objects in the study
|
|
# geompy.addToStudy( Sketch_1, 'Sketch_1' )
|
|
#
|
|
# # update object browser
|
|
# salome.sg.updateObjBrowser(1)
|
|
# @endcode
|
|
# @n Additionnal examples can be found as unit tests in the source code.
|
|
# @}
|
|
|
|
"""
|
|
\namespace geompy
|
|
\brief 2D and 3D Sketcher interfaces
|
|
"""
|
|
|
|
# This method is used by 3D Sketcher functionality
|
|
def printVar (var):
|
|
if isinstance(var, str):
|
|
return "\'%s\'"%var
|
|
else:
|
|
return "%.7f"%var
|
|
|
|
## An interface to build a 3D Sketcher step-by-step.
|
|
# Use geompy.Sketcher3D() method to obtain an instance of this class.
|
|
#
|
|
# @ref tui_3dsketcher_page "Example"
|
|
# @ingroup sketcher
|
|
class Sketcher3D:
|
|
"""
|
|
3D sketcher interface.
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher3D()
|
|
sk.addPointsAbsolute(0,0,0, 70,0,0)
|
|
sk.addPointsRelative(0, 0, 130)
|
|
sk.addPointRadiusAnglesRelative(50, 0, 100, 'OXY')
|
|
sk.addPointRadiusAnglesRelative(30, 80, 130, 'OXZ')
|
|
sk.close()
|
|
a3D_Sketcher_1 = sk.wire()
|
|
"""
|
|
|
|
def __init__(self, geompyD):
|
|
self.geompyD = geompyD
|
|
self.myCommand = "3DSketcher"
|
|
pass
|
|
|
|
## Add one or more points, sequentially connected with straight segments.
|
|
# Coordinates are considered as absolute.
|
|
# If the first point of sketcher is not yet defined, the first point
|
|
# from the listCoords will become the first sketcher point.
|
|
# @param listCoords X1, Y1, Z1, X2, Y2, Z2, ... Coordinates of points
|
|
def addPointsAbsolute (self, *listCoords):
|
|
"""
|
|
Add one or more points, sequentially connected with straight segments.
|
|
Coordinates are considered as absolute.
|
|
If the first point of sketcher is not yet defined, the first point
|
|
from the listCoords will become the first sketcher point.
|
|
|
|
Parameters:
|
|
X1, Y1, Z1, X2, Y2, Z2, ... Coordinates of points
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher3D()
|
|
sk.addPointsAbsolute(0,0,0, 70,0,0)
|
|
a3D_Sketcher_1 = sk.wire()
|
|
"""
|
|
ii = 1
|
|
for cc in listCoords:
|
|
if ii == 1:
|
|
self.myCommand = self.myCommand + ":TT"
|
|
self.myCommand = self.myCommand + " %s"%printVar(cc)
|
|
if ii == 3:
|
|
ii = 1
|
|
else:
|
|
ii = ii + 1
|
|
pass
|
|
|
|
## Add one or more points, sequentially connected with straight segments.
|
|
# Coordinates are considered relative to the previous point.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0, 0) will become the first sketcher point.
|
|
# @param listCoords X1, Y1, Z1, X2, Y2, Z2, ... Coordinates of points
|
|
def addPointsRelative (self, *listCoords):
|
|
"""
|
|
Add one or more points, sequentially connected with straight segments.
|
|
Coordinates are considered relative to the previous point.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
X1, Y1, Z1, X2, Y2, Z2, ... Relative coordinates of points
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher3D()
|
|
sk.addPointsRelative(0,0,130, 70,0,-130)
|
|
a3D_Sketcher_1 = sk.wire()
|
|
"""
|
|
ii = 1
|
|
for cc in listCoords:
|
|
if ii == 1:
|
|
self.myCommand = self.myCommand + ":T"
|
|
self.myCommand = self.myCommand + " %s"%printVar(cc)
|
|
if ii == 3:
|
|
ii = 1
|
|
else:
|
|
ii = ii + 1
|
|
pass
|
|
|
|
## Add one straight segment, defined by two angles and length.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0, 0) will become the first sketcher point.
|
|
# The radius and angles coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param length length of the segment
|
|
# @param angle1 angle in a plane, defined by the \a axes
|
|
# @param angle2 angle from the plane, defined by the \a axes
|
|
# @param axes can be: "OXY", "OYZ" or "OXZ"
|
|
def addPointRadiusAnglesRelative (self, length, angle1, angle2, axes="OXY"):
|
|
"""
|
|
Add one straight segment, defined by two angles and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
length length of the segment
|
|
angle1 angle in a plane, defined by the \a axes
|
|
angle2 angle from the plane, defined by the \a axes
|
|
axes can be: "OXY", "OYZ" or "OXZ"
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher3D()
|
|
sk.addPointRadiusAnglesRelative(100, 50, 0, "OXY")
|
|
a3D_Sketcher_1 = sk.wire()
|
|
"""
|
|
self.myCommand = self.myCommand + ":%s"%axes+"SR"+" %s %s %s" % (printVar(angle1), printVar(angle2), printVar(length))
|
|
pass
|
|
|
|
## Add one straight segment, defined by two angles and radius.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0, 0) will become the first sketcher point.
|
|
# The radius and angles coordinates are defined
|
|
# in a coordinate system which origin is the global coordinate system origin
|
|
#
|
|
# @param radius distance to the coordinate system origin
|
|
# @param angle1 angle in a plane, defined by the \a axes
|
|
# @param angle2 angle from the plane, defined by the \a axes
|
|
# @param axes can be: "OXY", "OYZ" or "OXZ"
|
|
def addPointRadiusAnglesAbsolute (self, radius, angle1, angle2, axes="OXY"):
|
|
"""
|
|
Add one straight segment, defined by two angles and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
radius distance to the coordinate system origin
|
|
angle1 angle in a plane, defined by the \a axes
|
|
angle2 angle from the plane, defined by the \a axes
|
|
axes can be: "OXY", "OYZ" or "OXZ"
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher3D()
|
|
sk.addPointRadiusAnglesAbsolute(100, 50, 0, "OXY")
|
|
a3D_Sketcher_1 = sk.wire()
|
|
"""
|
|
self.myCommand = self.myCommand + ":%s"%axes+"SA"+" %s %s %s" % (printVar(angle1), printVar(angle2), printVar(radius))
|
|
pass
|
|
|
|
## Add one straight segment, defined by an angle, a height and a radius.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0, 0) will become the first sketcher point.
|
|
# The radius height and angle coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param axes can be: "OXY", "OYZ" or "OXZ"
|
|
# @param angle angle in a plane, defined by the \a axes
|
|
# @param height height from the plane, defined by the \a axes
|
|
# @param length distance to the coordinate system origin
|
|
def addPointRadiusAngleHRelative (self, length, angle, height, axes="OXY"):
|
|
"""
|
|
Add one straight segment, defined by two angles and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
radius distance to the coordinate system origin
|
|
angle angle in a plane, defined by the \a axes
|
|
height height from the plane, defined by the \a axes
|
|
axes can be: "OXY", "OYZ" or "OXZ"
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher3D()
|
|
sk.addPointRadiusAngleHRelative(100, 50, 40, "OXY")
|
|
a3D_Sketcher_1 = sk.wire()
|
|
"""
|
|
self.myCommand = self.myCommand + ":%s"%axes+"CR"+" %s %s %s" % (printVar(angle), printVar(height), printVar(length))
|
|
pass
|
|
|
|
## Add one straight segment, defined by an angle, a height and a radius.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0, 0) will become the first sketcher point.
|
|
# The radius height and angle coordinates are defined
|
|
# in a coordinate system which origin is the global coordinate system origin
|
|
#
|
|
# @param radius distance to the coordinate system origin
|
|
# @param angle angle in a plane, defined by the \a axes
|
|
# @param height height from the plane, defined by the \a axes
|
|
# @param axes can be: "OXY", "OYZ" or "OXZ"
|
|
def addPointRadiusAngleHAbsolute (self, radius, angle, height, axes="OXY"):
|
|
"""
|
|
Add one straight segment, defined by two angles and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
axes can be: "OXY", "OYZ" or "OXZ"
|
|
angle1 angle in a plane, defined by the \a axes
|
|
height height from the plane, defined by the \a axes
|
|
radius distance to the coordinate system origin
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher3D()
|
|
sk.addPointRadiusAngleHAbsolute( 100, 50, 40, "OXY")
|
|
a3D_Sketcher_1 = sk.wire()
|
|
"""
|
|
self.myCommand = self.myCommand + ":%s"%axes+"CA"+" %s %s %s" % (printVar(angle), printVar(height), printVar(radius))
|
|
pass
|
|
|
|
## Set to close the wire
|
|
def close (self):
|
|
"""
|
|
Set to close the wire
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher3D()
|
|
sk.addPointsRelative(0,0,130, 70,0,-130)
|
|
sk.close()
|
|
a3D_Sketcher_1 = sk.wire()
|
|
"""
|
|
self.myCommand = self.myCommand + ":WW"
|
|
pass
|
|
|
|
## Obtain the sketcher result.
|
|
# @param theName Object name; when specified, this parameter is used
|
|
# for result publication in the study. Otherwise, if automatic
|
|
# publication is switched on, default value is used for result name.
|
|
#
|
|
# @return New GEOM_Object, containing the created wire
|
|
def wire (self, theName=None):
|
|
"""
|
|
Obtain the sketcher result.
|
|
|
|
Parameters:
|
|
theName Object name; when specified, this parameter is used
|
|
for result publication in the study. Otherwise, if automatic
|
|
publication is switched on, default value is used for result name.
|
|
|
|
Returns:
|
|
New GEOM_Object, containing the created wire.
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher3D()
|
|
sk.addPointsRelative(0,0,130, 70,0,-130)
|
|
a3D_Sketcher_1 = sk.wire()
|
|
"""
|
|
from salome.geom.geomBuilder import ParseSketcherCommand, RaiseIfFailed
|
|
Command,Parameters = ParseSketcherCommand(self.myCommand)
|
|
wire = self.geompyD.CurvesOp.Make3DSketcherCommand(Command)
|
|
self.myCommand = "3DSketcher"
|
|
RaiseIfFailed("Sketcher3D", self.geompyD.CurvesOp)
|
|
wire.SetParameters(Parameters)
|
|
self.geompyD._autoPublish(wire, theName, "wire")
|
|
return wire
|
|
|
|
## An interface to build a 2D Sketcher step-by-step.
|
|
# Use geompy.Sketcher2D() method to obtain an instance of this class.
|
|
# @ingroup sketcher
|
|
class Sketcher2D:
|
|
"""
|
|
2D sketcher interface.
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addPoint(20, 20)
|
|
sk.addSegmentRelative(15, 70)
|
|
sk.addSegmentPerpY(50)
|
|
sk.addArcRadiusRelative(25, 15, 14.5, 0)
|
|
sk.addArcCenterAbsolute(1, 1, 50, 50, 0, 0)
|
|
sk.addArcDirectionRadiusLength(20, 20, 101, 162.13)
|
|
sk.close()
|
|
Sketch_1 = sk.wire(geomObj_1)
|
|
"""
|
|
def __init__(self, geompyD):
|
|
self.geompyD = geompyD
|
|
self.myCommand = "Sketcher"
|
|
self.closed = False
|
|
pass
|
|
|
|
## Add one point.
|
|
# Used to set the starting point
|
|
#
|
|
# @param x, y - Coordinates of point
|
|
def addPoint (self, x, y):
|
|
"""
|
|
Add one point.
|
|
Used to set the starting point
|
|
|
|
Parameters:
|
|
x, y - Coordinates of point
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addPoint(20, 20)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":F %s %s" % (printVar(x), printVar(y))
|
|
pass
|
|
|
|
## Add angle.
|
|
# Used to set the angle for further building
|
|
#
|
|
# @param angle - angle in a plane
|
|
def addAngle (self, angle):
|
|
"""
|
|
Add angle.
|
|
Used to set the angle for further building
|
|
|
|
Parameters:
|
|
angle - angle in a plane
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addAngle(70)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":RR %s" % (printVar(angle))
|
|
pass
|
|
|
|
# Commands for creation of segment
|
|
|
|
## Add segment, which sequentially connects the previous point
|
|
# with a point lying on a line parallel to the axis Ox and the value x = param x.
|
|
# The current point will be the previous value to the coordinate y and
|
|
# new value to the coordinate x.
|
|
# Coordinate is considered relative to the previous point.
|
|
#
|
|
# @param x - Coordinate of point on axis Ox
|
|
def addSegmentParalX(self, x):
|
|
"""
|
|
Add segment, which sequentially connects the previous point
|
|
with a point lying on a line parallel to the axis Ox and the value x = param x.
|
|
The current point will be the previous value to the coordinate y and
|
|
new value to the coordinate x.
|
|
Coordinate is considered relative to the previous point.
|
|
|
|
Parameters:
|
|
x - Coordinate of point on axis Ox
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentParalX(40)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":X %s" % (printVar(x))
|
|
pass
|
|
|
|
## Add segment, which sequentially connects the previous point
|
|
# with a point lying on a line parallel to the axis Ox and the value x = 0
|
|
# The current point will be the previous value to the coordinate y.
|
|
def addSegmentParalXToZero(self):
|
|
"""
|
|
Add segment, which sequentially connects the previous point
|
|
with a point lying on a line parallel to the axis Ox and the value x = 0
|
|
The current point will be the previous value to the coordinate y.
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentParalXToZero()
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":XX"
|
|
pass
|
|
|
|
## Add segment, which sequentially connects the previous point
|
|
# with a point lying on a line parallel to the axis Oy and the value y = param y.
|
|
# The current point will be the previous value to the coordinate x and
|
|
# new value to the coordinate y.
|
|
# Coordinate is considered relative to the previous point.
|
|
#
|
|
# @param y - Coordinate of point on axis Oy
|
|
def addSegmentParalY(self, y):
|
|
"""
|
|
Add segment, which sequentially connects the previous point
|
|
with a point lying on a line parallel to the axis Oy and the value y = param y.
|
|
The current point will be the previous value to the coordinate x and
|
|
new value to the coordinate y.
|
|
Coordinate is considered relative to the previous point.
|
|
|
|
Parameters:
|
|
y - Coordinate of point on axis Oy
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentParalY(80)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":Y %s" % (printVar(y))
|
|
pass
|
|
|
|
## Add segment, which sequentially connects the previous point
|
|
# with a point lying on a line parallel to the axis Ox and the value x = 0
|
|
# The current point will be the previous value to the coordinate y.
|
|
def addSegmentParalYToZero(self):
|
|
"""
|
|
Add segment, which sequentially connects the previous point
|
|
with a point lying on a line parallel to the axis Oy and the value y = 0
|
|
The current point will be the previous value to the coordinate x.
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentParalYToZero()
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":YY"
|
|
pass
|
|
|
|
## Add segment, which sequentially connects the given point with previous point
|
|
#
|
|
# Coordinates are considered as absolute.
|
|
# @param x, y - Coordinates of point
|
|
def addSegmentAbsolute (self, x, y):
|
|
"""
|
|
Add segment, which sequentially connects the starting point with the given point
|
|
Coordinates are considered as absolute.
|
|
|
|
Parameters:
|
|
x, y - Coordinates of point
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentAbsolute(30, 50)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":TT %s %s" % (printVar(x), printVar(y))
|
|
pass
|
|
|
|
## Add segment, which sequentially connects the given point with previous point
|
|
# Coordinates are considered relative to the previous point.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
#
|
|
# @param dx, dy - Coordinates of point relative a previous point
|
|
def addSegmentRelative (self, dx, dy):
|
|
"""
|
|
Add segment, which sequentially connects the given point with previous point
|
|
Coordinates are considered relative to the previous point.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
dx, dy - Coordinates of point relative a previous point
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentRelative(60, 10)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":T %s %s" % (printVar(dx), printVar(dy))
|
|
pass
|
|
|
|
## Add one straight segment, defined by angle and length.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The angle and length coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param angle - angle in a plane
|
|
# @param length - length of the segment
|
|
def addSegmentAngleLength (self, angle, length ):
|
|
"""
|
|
Add one straight segment, defined by angle and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The radius and angles coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
angle - angle in a plane
|
|
length - length of the segment
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentAngleLength(10, 30)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":R %s:L %s" % (printVar(angle), printVar(length))
|
|
pass
|
|
|
|
## Add one straight segment, defined by angle and intersect straight x= param x.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The angle and point's coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param angle - angle in a plane
|
|
# @param x - value on the axis Ox
|
|
def addSegmentAngleX (self, angle, x ):
|
|
"""
|
|
Add one straight segment, defined by angle and intersect straight x= param x.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The angle and point's coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
angle - angle in a plane
|
|
x - value on the axis Ox
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentAngleX(25, 90)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":R %s:IX %s" % (printVar(angle), printVar(x))
|
|
pass
|
|
|
|
## Add one straight segment, defined by angle and intersect straight y= param y.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The angle and point's coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param angle - angle in a plane
|
|
# @param y - value on the axis Oy
|
|
def addSegmentAngleY (self, angle, y ):
|
|
"""
|
|
Add one straight segment, defined by angle and intersect straight y= param y.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The angle and point's coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
angle - angle in a plane
|
|
y - value on the axis Oy
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentAngleY(40, 0)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":R %s:IY %s" % (printVar(angle), printVar(y))
|
|
pass
|
|
|
|
|
|
## Add one straight segment, defined by perpendicular(angle=90) and length.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The length coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param length - length of the segment
|
|
def addSegmentPerpLength (self, length ):
|
|
"""
|
|
Add one straight segment, defined by perpendicular and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The length coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
length - length of the segment
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentPerpLength(100)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":R 90:L %s" % (printVar(length))
|
|
pass
|
|
|
|
## Add one straight segment, defined by perpendicular(angle=90) and intersect straight x= param x.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The point's coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param x - value on the axis Ox
|
|
def addSegmentPerpX (self, x ):
|
|
"""
|
|
Add one straight segment, defined by perpendicular(angle=90) and intersect straight x= param x.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The point's coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
x - value on the axis Ox
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentPerpX(30)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":R 90:IX %s" % (printVar(x))
|
|
pass
|
|
|
|
## Add one straight segment, defined by perpendicular(angle=90) and intersect straight y= param y.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The point's coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param y - value on the axis Oy
|
|
def addSegmentPerpY (self, y ):
|
|
"""
|
|
Add one straight segment, defined by perpendicular(angle=90) and intersect straight y= param y.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The point's coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
y - value on the axis Oy
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentPerpY(10)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":R 90:IY %s" % (printVar(y))
|
|
pass
|
|
|
|
|
|
## Add one straight segment, defined by previous direction and length.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The length coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param length - length of the segment
|
|
def addSegmentLength (self, length ):
|
|
"""
|
|
Add one straight segment, defined by previous direction and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The length coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
length - length of the segment
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentLength(100)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":L %s" % (printVar(length))
|
|
pass
|
|
|
|
## Add one straight segment, defined by previous direction and intersect straight x= param x.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The point's coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param x - value on the axis Ox
|
|
def addSegmentX (self, x ):
|
|
"""
|
|
Add one straight segment, defined by previous direction and intersect straight x= param x.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The point's coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
x - value on the axis Ox
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentX(30)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":IX %s" % (printVar(x))
|
|
pass
|
|
|
|
## Add one straight segment, defined by previous direction and intersect straight y= param y.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The point's coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param y - value on the axis Oy
|
|
def addSegmentY (self, y ):
|
|
"""
|
|
Add one straight segment, defined by previous direction and intersect straight y= param y.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The point's coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
y - value on the axis Oy
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentY(10)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":IY %s" % (printVar(y))
|
|
pass
|
|
|
|
|
|
## Add one straight segment, defined by direction and length.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The direction and length coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param dx, dy - direction of the segment
|
|
# @param length - length of the segment
|
|
def addSegmentDirectionLength (self, dx, dy, length ):
|
|
"""
|
|
Add one straight segment, defined by direction and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The direction and length coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
dx, dy - direction of the segment
|
|
length - length of the segment
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentDirectionLength(20, 40, 30)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":D %s %s:L %s" % (printVar(dx), printVar(dy), printVar(length))
|
|
pass
|
|
|
|
## Add one straight segment, defined by direction and intersect straight x= param x.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The direction and point's coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param dx, dy - direction of the segment
|
|
# @param x - value on the axis Ox
|
|
def addSegmentDirectionX (self, dx, dy, x ):
|
|
"""
|
|
Add one straight segment, defined by direction and intersect straight x= param x.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The direction and point's coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
dx, dy - direction of the segment
|
|
x - value on the axis Ox
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentDirectionX(10, -40, 20)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":D %s %s:IX %s" % (printVar(dx), printVar(dy), printVar(x))
|
|
pass
|
|
|
|
## Add one straight segment, defined by direction and intersect straight y= param y.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
# The direction and point's coordinates are defined
|
|
# in a local coordinate system which origin is the last point of the sketch
|
|
#
|
|
# @param dx, dy - direction of the segment
|
|
# @param y - value on the axis Oy
|
|
def addSegmentDirectionY (self, dx, dy, y ):
|
|
"""
|
|
Add one straight segment, defined by direction and intersect straight y= param y.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
The direction and point's coordinates are defined
|
|
in a local coordinate system which origin is the last point of the sketch
|
|
|
|
Parameters:
|
|
dx, dy - direction of the segment
|
|
y - value on the axis Oy
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addSegmentDirectionY(-10, -50, 20)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":D %s %s:IY %s" % (printVar(dx), printVar(dy), printVar(y))
|
|
pass
|
|
|
|
# Commands for creation of arc
|
|
|
|
## Add arc, which connects the given point with previous point
|
|
# Coordinates are considered as absolute.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
#
|
|
# @param x, y - Coordinates of second point of arc
|
|
def addArcAbsolute (self, x, y ):
|
|
"""
|
|
Add arc, which connects the given point with previous point
|
|
Coordinates are considered as absolute.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
param x, y - Coordinates of second point of arc
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcAbsolute(50, 10)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":AA %s %s" % (printVar(x), printVar(y))
|
|
pass
|
|
|
|
## Add arc, which connects the given point with previous point
|
|
# Coordinates are considered relative to the previous point.
|
|
#
|
|
# @param dx, dy - Coordinates of second point of arc relative to the previous point
|
|
def addArcRelative (self, dx, dy ):
|
|
"""
|
|
Add arc, which connects the given point with previous point
|
|
Coordinates are considered relative to the previous point.
|
|
|
|
Parameters:
|
|
param dx, dy - Coordinates of second point of arc
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcRelative(50, 10)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":A %s %s" % (printVar(dx), printVar(dy))
|
|
pass
|
|
|
|
## Add arc, defined by radius and coordinates of next point.
|
|
# Coordinates are considered as absolute.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
#
|
|
# @param x, y - Coordinates of second point of arc
|
|
# @param radius - radius of arc
|
|
# @param flag - is 0 or 2
|
|
# if 0 the drawn arc is the one of lower angle (<Pi)
|
|
# if 2 the drawn arc is the one of greater angle (>Pi)
|
|
def addArcRadiusAbsolute (self, x, y, radius, flag ):
|
|
"""
|
|
Add arc, defined by radius and coordinates of next point.
|
|
Coordinates are considered as absolute.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
param x, y - Coordinates of second point of arc
|
|
param radius - radius of arc
|
|
param flag - is 0 or 2
|
|
if 0 the drawn arc is the one of lower angle (<Pi)
|
|
if 2 the drawn arc is the one of greater angle (>Pi)
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcRadiusAbsolute(50, 10, 20, 0)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":UU %s %s %s %s" % (printVar(x), printVar(y), printVar(radius), printVar(flag))
|
|
pass
|
|
|
|
## Add arc, defined by radius and coordinates of next point.
|
|
# Coordinates are considered relative to the previous point.
|
|
#
|
|
# @param dx, dy - Coordinates of second point of arc
|
|
# @param radius - radius of arc
|
|
# @param flag - is 0 or 2
|
|
# if 0 the drawn arc is the one of lower angle (<Pi)
|
|
# if 2 the drawn arc is the one of greater angle (>Pi)
|
|
def addArcRadiusRelative (self, dx, dy, radius, flag ):
|
|
"""
|
|
Add arc, defined by radius and coordinates of next point.
|
|
Coordinates are considered relative to the previous point.
|
|
|
|
Parameters:
|
|
param dx, dy - Coordinates of second point of arc
|
|
param radius - radius of arc
|
|
param flag - is 0 or 2
|
|
if 0 the drawn arc is the one of lower angle (<Pi)
|
|
if 2 the drawn arc is the one of greater angle (>Pi)
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcRadiusRelative(-30, -15, 20, 2)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":U %s %s %s %s" % (printVar(dx), printVar(dy), printVar(radius), printVar(flag))
|
|
pass
|
|
|
|
## Add arc, defined by coordinates of next point and coordinates of center.
|
|
# Coordinates are considered as absolute.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
#
|
|
# @param x, y - Coordinates of second point of arc
|
|
# @param xc, yc - Coordinates of center
|
|
# @param flag1 - (reverse) is 0 or 2
|
|
# if 0 the drawn arc is the one of lower angle (<Pi)
|
|
# if 2 the drawn arc is the one of greater angle (>Pi)
|
|
# @param flag2 - (control tolerance) is 0 or 1
|
|
# if 0 the specified end point can be at a distance of the arc
|
|
def addArcCenterAbsolute (self, x, y, xc, yc, flag1, flag2 ):
|
|
"""
|
|
Add arc, defined by coordinates of next point and coordinates of center.
|
|
Coordinates are considered as absolute.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
param x, y - Coordinates of second point of arc
|
|
param xc, yc - Coordinates of center
|
|
param flag1 - is 0 or 2
|
|
if 0 the drawn arc is the one of lower angle (<Pi)
|
|
if 2 the drawn arc is the one of greater angle (>Pi)
|
|
param flag2 - (control tolerance) is 0 or 1
|
|
if 0 the specified end point can be at a distance of the arc
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcCenterAbsolute(-30, -15, 20, 10, 0, 0)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":EE %s %s %s %s %s %s" % (printVar(xc), printVar(yc), printVar(x), printVar(y),
|
|
printVar(flag1), printVar(flag2))
|
|
pass
|
|
|
|
## Add arc, defined by coordinates of next point and coordinates of center.
|
|
# Coordinates are considered relative to the previous point.
|
|
#
|
|
# @param dx, dy - Coordinates of second point of arc
|
|
# @param xc, yc - Coordinates of center
|
|
# @param flag1 - (reverse) is 0 or 2
|
|
# if 0 the drawn arc is the one of lower angle (<Pi)
|
|
# if 2 the drawn arc is the one of greater angle (>Pi)
|
|
# @param flag2 - (control tolerance) is 0 or 1
|
|
# if 0 the specified end point can be at a distance of the arc
|
|
def addArcCenterRelative (self, dx, dy, xc, yc, flag1, flag2 ):
|
|
"""
|
|
Add arc, defined by coordinates of next point and coordinates of center.
|
|
Coordinates are considered relative to the previous point.
|
|
|
|
Parameters:
|
|
param dx, dy - Coordinates of second point of arc
|
|
param xc, yc - Coordinates of center
|
|
param flag1 - is 0 or 2
|
|
if 0 the drawn arc is the one of lower angle (<Pi)
|
|
if 2 the drawn arc is the one of greater angle (>Pi)
|
|
param flag2 - (control tolerance) is 0 or 1
|
|
if 0 the specified end point can be at a distance of the arc
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcCenterRelative(-30, -15, 20, 10, 2, 1)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":E %s %s %s %s %s %s" % (printVar(xc), printVar(yc), printVar(dx), printVar(dy),
|
|
printVar(flag1), printVar(flag2))
|
|
pass
|
|
|
|
## Add arc, defined by angle, radius and length.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
#
|
|
# @param angle - angle in a plane
|
|
# @param radius - radius of the arc
|
|
# @param length - length of the arc
|
|
def addArcAngleRadiusLength (self, angle, radius, length ):
|
|
"""
|
|
Add arc, defined by angle, radius and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
param angle - angle in a plane
|
|
param radius - radius of the arc
|
|
param length - length of the arc
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcAngleRadiusLength(30, 15, 40)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":R %s:C %s %s" % (printVar(angle), printVar(radius), printVar(length))
|
|
pass
|
|
|
|
## Add arc, defined by perpendicular(angle=90), radius and length.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
#
|
|
# @param radius - radius of the arc
|
|
# @param length - length of the arc
|
|
def addArcPerpRadiusLength (self, radius, length ):
|
|
"""
|
|
Add arc, defined by perpendicular(angle=90), radius and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
param radius - radius of the arc
|
|
param length - length of the arc
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcPerpRadiusLength(15, 40)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":R 90:C %s %s" % (printVar(radius), printVar(length))
|
|
pass
|
|
|
|
## Add arc, defined by previous direction, radius and length.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
#
|
|
# @param radius - radius of the arc
|
|
# @param length - length of the arc
|
|
def addArcRadiusLength (self, radius, length ):
|
|
"""
|
|
Add arc, defined by previous direction, radius and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
param radius - radius of the arc
|
|
param length - length of the arc
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcRadiusLength(15, 40)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":C %s %s" % (printVar(radius), printVar(length))
|
|
pass
|
|
|
|
## Add arc, defined by direction, radius and length.
|
|
# If the first point of sketcher is not yet defined, the
|
|
# origin (0, 0) will become the first sketcher point.
|
|
#
|
|
# @param dx, dy - direction of the arc
|
|
# @param radius - radius of the arc
|
|
# @param length - length of the arc
|
|
def addArcDirectionRadiusLength (self, dx, dy, radius, length ):
|
|
"""
|
|
Add arc, defined by direction, radius and length.
|
|
If the first point of sketcher is not yet defined, the
|
|
origin (0, 0) will become the first sketcher point.
|
|
|
|
Parameters:
|
|
param dx, dy - direction of the arc
|
|
param radius - radius of the arc
|
|
param length - length of the arc
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addArcDirectionRadiusLength(-50, 40, 20, 3.5)
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.myCommand = self.myCommand + ":D %s %s:C %s %s" % (printVar(dx), printVar(dy), printVar(radius), printVar(length))
|
|
pass
|
|
|
|
## Set to close the wire
|
|
def close (self):
|
|
"""
|
|
Set to close the wire
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addPoint(15, 85.6)
|
|
sk.close()
|
|
Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
self.closed = True
|
|
pass
|
|
|
|
## Obtain the sketcher result as a wire.
|
|
#
|
|
# @param WorkingPlane - current Working Plane used for this 2DSketcher
|
|
# @param theName Object name; when specified, this parameter is used
|
|
# for result publication in the study. Otherwise, if automatic
|
|
# publication is switched on, default value is used for result name.
|
|
#
|
|
# @return New GEOM_Object, containing the created wire
|
|
def wire (self, WorkingPlane=[0, 0, 0, 0, 0, 1, 1, 0, 0], theName=None):
|
|
"""
|
|
Obtain the sketcher result as a wire.
|
|
|
|
Parameters:
|
|
theName Object name; when specified, this parameter is used
|
|
for result publication in the study. Otherwise, if automatic
|
|
publication is switched on, default value is used for result name
|
|
param WorkingPlane - current Working Plane used for this 2DSketcher
|
|
|
|
Returns:
|
|
New GEOM_Object, containing the created wire.
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addPoint(30, 70)
|
|
a3D_Sketcher_1 = sk.wire(geomObj_1)
|
|
"""
|
|
|
|
if self.closed:
|
|
self.myCommand = self.myCommand + ":WW"
|
|
|
|
import GEOM
|
|
if isinstance(WorkingPlane, list): wire = self.geompyD.CurvesOp.MakeSketcher(self.myCommand, WorkingPlane)
|
|
if isinstance(WorkingPlane, GEOM._objref_GEOM_Object): wire = self.geompyD.CurvesOp.MakeSketcherOnPlane(self.myCommand, WorkingPlane)
|
|
|
|
self.myCommand = "Sketcher"
|
|
self.geompyD._autoPublish(wire, theName, "wire")
|
|
return wire
|
|
|
|
## Obtain the sketcher result as a face.
|
|
#
|
|
# @param WorkingPlane - current Working Plane used for this 2DSketcher
|
|
# @param theName Object name; when specified, this parameter is used
|
|
# for result publication in the study. Otherwise, if automatic
|
|
# publication is switched on, default value is used for result name.
|
|
#
|
|
# @return New GEOM_Object, containing the created face
|
|
def face (self, WorkingPlane=[0, 0, 0, 0, 0, 1, 1, 0, 0], theName=None):
|
|
"""
|
|
Obtain the sketcher result as a face.
|
|
|
|
Parameters:
|
|
theName Object name; when specified, this parameter is used
|
|
for result publication in the study. Otherwise, if automatic
|
|
publication is switched on, default value is used for result name
|
|
param WorkingPlane - current Working Plane used for this 2DSketcher
|
|
|
|
Returns:
|
|
New GEOM_Object, containing the created face.
|
|
|
|
Example of usage:
|
|
sk = geompy.Sketcher2D()
|
|
sk.addPoint(0, 0)
|
|
sk.addSegment(100, 0)
|
|
sk.addSegment(100, 100)
|
|
sk.addSegment(0, 100)
|
|
sk.close()
|
|
a3D_Sketcher_1 = sk.face(geomObj_1)
|
|
"""
|
|
|
|
if self.closed:
|
|
self.myCommand = self.myCommand + ":WF"
|
|
else:
|
|
raise RuntimeError, "Sketcher2D.close() : can't build face on unclosed wire"
|
|
|
|
import GEOM
|
|
if isinstance(WorkingPlane, list): face = self.geompyD.CurvesOp.MakeSketcher(self.myCommand, WorkingPlane)
|
|
if isinstance(WorkingPlane, GEOM._objref_GEOM_Object): face = self.geompyD.CurvesOp.MakeSketcherOnPlane(self.myCommand, WorkingPlane)
|
|
|
|
self.myCommand = "Sketcher"
|
|
self.geompyD._autoPublish(face, theName, "face")
|
|
return face
|
|
|
|
## An interface to build a 2D polyline step-by-step. The polyline can contain
|
|
# several sections. Each section represents a list of 2d points. As well it
|
|
# has a name, curve type, either polyline or interpolation (BSpline curve) and
|
|
# Closed flag.
|
|
# Use geompy.Polyline2D() method to obtain an instance of this class.
|
|
# @ingroup sketcher
|
|
class Polyline2D:
|
|
"""
|
|
An interface to build a 2D polyline step-by-step. The polyline can contain
|
|
several sections. Each section represents a list of 2d points. As well it
|
|
has a name, curve type, either polyline or interpolation (BSpline curve) and
|
|
Closed flag.
|
|
Use geompy.Polyline2D() method to obtain an instance of this class.
|
|
|
|
Example of usage:
|
|
pl = geompy.Polyline2D()
|
|
pl.addSection("section 1", GEOM.Polyline, True, [0, 0, 10, 0, 10, 10])
|
|
pl.addSection("section 2", GEOM.Interpolation, False)
|
|
pl.addPoints([20, 0, 30, 0, 30, 10])
|
|
resultObj = pl.result(WorkingPlane)
|
|
"""
|
|
|
|
def __init__(self, geompyD):
|
|
self.geompyD = geompyD
|
|
self.myNameList = []
|
|
self.myTypeList = []
|
|
self.myClosedList = []
|
|
self.myCoordsList = []
|
|
pass
|
|
|
|
## Add a new section to the polyline.
|
|
#
|
|
# @param theName the name
|
|
# @param theType the type. It can have either CORBA enumeration type
|
|
# GEOM.curve_type or a value of type long. Possible input values
|
|
# are: GEOM.Polyline(0) and GEOM.Interpolation(2).
|
|
# @param theClosed True for closed section; False otherwise
|
|
# @param thePoints the list of 2D points coordinates in the form:
|
|
# [x1, y1, x2, y2, ..., xN, yN] for N points.
|
|
def addSection(self, theName, theType, theClosed, thePoints = None):
|
|
"""
|
|
Add a new section to the polyline.
|
|
|
|
Parameters:
|
|
theName the name
|
|
theType the type. It can have either CORBA enumeration type
|
|
GEOM.curve_type or a value of type long. Possible input
|
|
values are: GEOM.Polyline(0) and GEOM.Interpolation(2).
|
|
theClosed True for closed section; False otherwise
|
|
thePoints the list of 2D points coordinates in the form:
|
|
[x1, y1, x2, y2, ..., xN, yN] for N points.
|
|
|
|
Example of usage:
|
|
pl = geompy.Polyline2D()
|
|
pl.addSection("section 1", GEOM.Polyline, True, [0, 0, 10, 0, 10, 10])
|
|
resultObj = pl.result(WorkingPlane)
|
|
"""
|
|
from salome.geom.geomBuilder import EnumToLong
|
|
self.myNameList.append(theName)
|
|
self.myTypeList.append(EnumToLong(theType))
|
|
self.myClosedList.append(theClosed)
|
|
if thePoints is None:
|
|
self.myCoordsList.append([])
|
|
else:
|
|
self.myCoordsList.append(thePoints)
|
|
pass
|
|
|
|
## Add a points to the last added section of the polyline. If there are
|
|
# no sections in the polyline it does nothing.
|
|
#
|
|
# @param thePoints the list of 2D points coordinates in the form:
|
|
# [x1, y1, x2, y2, ..., xN, yN] for N points.
|
|
def addPoints(self, thePoints):
|
|
"""
|
|
Add a points to the last added section of the polyline. If there are
|
|
no sections in the polyline it does nothing.
|
|
|
|
Parameters:
|
|
thePoints the list of 2D points coordinates in the form:
|
|
[x1, y1, x2, y2, ..., xN, yN] for N points.
|
|
|
|
Example of usage:
|
|
pl = geompy.Polyline2D()
|
|
pl.addSection("section 1", GEOM.Polyline, True)
|
|
pl.addPoints([0, 0, 10, 0, 10, 10])
|
|
pl.addPoints([20, 0, 30, 0, 30, 10])
|
|
resultObj = pl.result(WorkingPlane)
|
|
"""
|
|
if self.myNameList:
|
|
self.myCoordsList[-1].extend(thePoints)
|
|
pass
|
|
|
|
## Obtain the 2D polyline result as a wire or a compound of wires in case
|
|
# of several sections defined.
|
|
#
|
|
# @param theWorkingPlane - current Working Plane used for this 2D polyline
|
|
# @param theName Object name; when specified, this parameter is used
|
|
# for result publication in the study. Otherwise, if automatic
|
|
# publication is switched on, default value is used for result name.
|
|
#
|
|
# @return New GEOM_Object, containing the created shape.
|
|
def result(self, theWorkingPlane=[0, 0, 0, 0, 0, 1, 1, 0, 0], theName=None):
|
|
"""
|
|
Obtain the 2D polyline result as a wire or a compound of wires in case
|
|
of several sections defined.
|
|
|
|
Parameters:
|
|
theWorkingPlane current Working Plane used for this 2D polyline
|
|
theName Object name; when specified, this parameter is used
|
|
for result publication in the study. Otherwise, if automatic
|
|
publication is switched on, default value is used for result name.
|
|
|
|
Returns:
|
|
New GEOM_Object, containing the created shape.
|
|
|
|
Example of usage:
|
|
pl = geompy.Polyline2D()
|
|
pl.addSection("section 1", GEOM.Polyline, True, [0, 0, 10, 0, 10, 10])
|
|
pl.addSection("section 2", GEOM.Interpolation, False)
|
|
pl.addPoints([20, 0, 30, 0, 30, 10])
|
|
resultObj = pl.result(WorkingPlane)
|
|
"""
|
|
from salome.geom.geomBuilder import RaiseIfFailed
|
|
import GEOM
|
|
if isinstance(theWorkingPlane, list):
|
|
aResult = self.geompyD.CurvesOp.MakePolyline2D(
|
|
self.myCoordsList, self.myNameList, self.myTypeList,
|
|
self.myClosedList, theWorkingPlane)
|
|
if isinstance(theWorkingPlane, GEOM._objref_GEOM_Object):
|
|
aResult = self.geompyD.CurvesOp.MakePolyline2DOnPlane(
|
|
self.myCoordsList, self.myNameList, self.myTypeList,
|
|
self.myClosedList, theWorkingPlane)
|
|
|
|
self.myNameList = []
|
|
self.myTypeList = []
|
|
self.myClosedList = []
|
|
self.myCoordsList = []
|
|
RaiseIfFailed("Polyline2D.result", self.geompyD.CurvesOp)
|
|
self.geompyD._autoPublish(aResult, theName, "polyline")
|
|
|
|
return aResult
|