"""Sketcher interface.
This interface allows to add a sketch
in a part or partset.
-The created sketch object provides all the needed methods
+The created sketch object provides all the needed methods
for sketch modification and constraint edition.
Example of code:
-.. doctest::
+.. doctest::
>>> import model
>>> model.begin()
>>> plane = model.defaultPlane("XOY")
>>> sketch = model.addSketch(part, plane)
>>> line = sketch.addLine(0, 0, 0, 1)
+ >>> line.endPoint().x()
+ 0.0
+ >>> line.endPoint().y()
+ 1.0
"""
from ModelAPI import modelAPI_ResultConstruction, featureToCompositeFeature
Arguments:
document(ModelAPI_Document): part or partset document
plane(geom.Ax3): plane on wich the sketch is built
-
+
Returns:
Sketch: sketch object
"""
)
self._external = self._feature.data().selection("External")
- # If no arguments are given the attributes of the feature
+ # If no arguments are given the attributes of the feature
# are not Initialized
if args is not None:
plane = args[0]
def addLine(self, *args):
"""Add a line to the sketch.
-
+
.. function:: addLine(name)
- Select an existing line. The line is added to the sketch with a rigid
+ Select an existing line. The line is added to the sketch with a rigid
constraint (it cannot be modified by the sketch)
-
+
Arguments:
name(str): name of an existing line
-
+
.. function:: addLine(start, end)
Create a line by points
-
+
Arguments:
start(point): start point of the line
end(point): end point of the line
-
+
.. function:: addLine(start_x, start_y, end_x, end_y)
Create a line by coordinates
-
+
Arguments:
start_x(double): start point x coordinate
"""
circle_feature = self._feature.addFeature("SketchCircle")
return Circle(circle_feature, *args)
- def addArc(self, *args):
+ def addArc(self, *args, **kwargs):
"""Add an arc of circle to the sketch and return an arc object.
-
+
Two different syntaxes are allowed:
-
+
.. function:: addArc(center, start, end)
-
+
Arguments:
- center (point): center of the arc
+ center (point): center of the arc
start (point): start point of the arc
end (point): end point of the arc
-
+
.. function:: addArc(center_x, center_y, start_x, start_y, end_x, end_y)
-
+
Same as above but with coordinates
-
+
Returns:
Arc: arc object
Raises:
if not args:
raise TypeError("No arguments given")
arc_feature = self._feature.addFeature("SketchArc")
- return Arc(arc_feature, *args)
+ return Arc(arc_feature, *args, **kwargs)
#-------------------------------------------------------------
#
constraint to this Sketch."""
# assert(p1 and p2) NOTE : if an argument is missing python
# will raise TypeError by itself.
- # It seems better to check only that provided arguments are not
+ # It seems better to check only that provided arguments are not
# None
if p1 is None or p2 is None:
raise TypeError("NoneType argument given")
constraint = self._feature.addFeature("SketchConstraintCoincidence")
- constraint.data().refattr("ConstraintEntityA").setAttr(p1)
- constraint.data().refattr("ConstraintEntityB").setAttr(p2)
+ self._fillAttribute(constraint.refattr("ConstraintEntityA"), p1)
+ self._fillAttribute(constraint.refattr("ConstraintEntityB"), p2)
self.execute()
return constraint
raise TypeError("NoneType argument given")
constraint = self._feature.addFeature("SketchConstraintLength")
constraint.data().refattr("ConstraintEntityA").setObject(line)
- constraint.data().real("ConstraintValue").setValue(length)
+ self._fillAttribute(constraint.real("ConstraintValue"), length)
self.execute()
return constraint
"""Set the radius of the given circle and add the corresponding
constraint to this Sketch."""
constraint = self._feature.addFeature("SketchConstraintRadius")
- constraint.data().refattr("ConstraintEntityA").setObject(circle)
- constraint.data().real("ConstraintValue").setValue(radius)
+ self._fillAttribute(constraint.refattr("ConstraintEntityA"), circle)
+ self._fillAttribute(constraint.real("ConstraintValue"), radius)
self.execute()
return constraint
self.execute()
return constraint
- def setFillet(self, line_1, line_2, radius):
+ def setFillet(self, *args):
"""Set a fillet constraint between the 2 given lines with the given
filleting radius."""
+ assert(args)
constraint = self._feature.addFeature("SketchConstraintFillet")
- constraint.data().refattr("ConstraintEntityA").setObject(line_1)
- constraint.data().reflist("ConstraintEntityB").clear()
- constraint.data().reflist("ConstraintEntityB").append(line_2)
+ if len(args) == 3:
+ line_1, line_2, radius = args
+ constraint.data().refattr("ConstraintEntityA").setObject(line_1)
+ constraint.data().reflist("ConstraintEntityB").clear()
+ constraint.data().reflist("ConstraintEntityB").append(line_2)
+ elif len(args) == 2:
+ point, radius = args
+ self._fillAttribute(constraint.data().refattrlist("ConstraintEntityA"), [point])
+ self._fillAttribute(constraint.real("ConstraintValue"), radius)
self.execute()
return constraint
-
+
def setRigid(self, object_):
"""Set a rigid constraint on a given object."""
constraint = self._feature.addFeature("SketchConstraintRigid")
- constraint.data().refattr("ConstraintEntityA").setObject(object_)
+ self._fillAttribute(constraint.refattr("ConstraintEntityA"), object_)
self.execute()
return constraint
-
+
#-------------------------------------------------------------
#
# Transformation constraints
#
#-------------------------------------------------------------
-
+
def addMirror(self, mirror_line, sketch_objects):
"""Add a mirror transformation of the given objects to the sketch.
-
+
This transformation is a constraint.
-
+
:return: interface to the constraint
:rtype: Mirror object
"""
mirror_interface = Mirror(mirror_constraint, mirror_line, sketch_objects)
self.execute()
return mirror_interface
-
+
#-------------------------------------------------------------
#
# Adding and connecting next lines
for c2 in coords[2:]:
line_2 = self.addLine(c1, c2)
- self.setCoincident(line_1.endPointData(), line_2.startPointData())
+ self.setCoincident(line_1.endPoint(), line_2.startPoint())
polyline.append(line_2)
c1 = c2
line_1 = line_2
cn = coords[len(coords) - 1]
ln = self.addLine(cn, c0)
self.setCoincident(
- pg[len(coords) - 2].endPointData(), ln.startPointData()
+ pg[len(coords) - 2].endPoint(), ln.startPoint()
)
self.setCoincident(
- ln.endPointData(), pg[0].startPointData()
+ ln.endPoint(), pg[0].startPoint()
)
pg.append(ln)
return pg
