1 """Sketch Feature Interface
2 Author: Daniel Brunier-Coulin with contribution by Mikhail Ponikarov
3 Copyright (C) 2014-20xx CEA/DEN, EDF R&D
7 from GeomDataAPI import *
8 from GeomAlgoAPI import *
13 def __init__(self, doc, plane):
14 """Initializes a 2D Sketch on the given plane and adds the Sketch to the given Part or Partset.
15 The plane can be defined either by:
16 - a 3D axis system (geom.Ax3),
17 - an existing face identified by its topological name.
19 self.my = featureToCompositeFeature( doc.addFeature("Sketch") )
20 self.selection = None # Entities used for building the result shape
21 # self.resultype ="Face" # Type of Sketch result
22 if isinstance(plane, str):
23 self.__sketchOnFace(doc, plane)
25 self.__sketchOnPlane(doc, plane)
27 def __sketchOnPlane (self, doc, plane):
30 dx = plane.xDirection()
31 geomDataAPI_Point( self.my.data().attribute("Origin") ).setValue( o.x(), o.y(), o.z() )
32 geomDataAPI_Dir( self.my.data().attribute("DirX") ).setValue( dx.x(), dx.y(), dx.z() )
33 geomDataAPI_Dir( self.my.data().attribute("Norm") ).setValue( d.x(), d.y(), d.z() )
35 def __sketchOnFace (self, doc, plane):
36 self.my.data().selection("External").selectSubShape("FACE", plane)
39 # Creation of Geometries
41 def addPoint (self, *args):
42 """Adds a point to this Sketch."""
43 return Point(self.my, *args)
45 def addLine (self, *args):
46 """Adds a line to this Sketch."""
47 return Line(self.my, *args)
49 def addPolyline (self, *coords):
50 """Adds a poly-line to this Sketch.
51 The end of consecutive segments are defined as coincident.
56 l1 = self.addLine(c0, c1)
58 # Adding and connecting next lines
60 l2 = self.addLine(c1, c2)
61 self.setCoincident( l1.endPointData(), l2.startPointData() )
67 def addPolygon (self, *coords):
68 """Adds a polygon to this Sketch.
69 The end of consecutive segments are defined as coincident.
71 pg = self.addPolyline(*coords)
72 # Closing the poly-line supposed being defined by at least 3 points
74 cn = coords[len(coords)-1]
75 ln = self.addLine(cn, c0)
76 self.setCoincident( pg[len(coords)-2].endPointData(), ln.startPointData() )
77 self.setCoincident( ln.endPointData(), pg[0].startPointData() )
81 def addCircle (self, *args):
82 """Adds a circle to this Sketch."""
83 return Circle(self.my, *args)
86 # Creation of Geometrical and Dimensional Constraints
88 def setCoincident (self, p1, p2):
89 """Sets coincident the two given points and adds the corresponding constraint to this Sketch."""
90 constraint = self.my.addFeature("SketchConstraintCoincidence")
91 constraint.data().refattr("ConstraintEntityA").setAttr(p1)
92 constraint.data().refattr("ConstraintEntityB").setAttr(p2)
95 def setParallel (self, l1, l2):
96 """Sets parallel the two given lines and adds the corresponding constraint to this Sketch."""
97 constraint = self.my.addFeature("SketchConstraintParallel")
98 constraint.data().refattr("ConstraintEntityA").setObject(l1)
99 constraint.data().refattr("ConstraintEntityB").setObject(l2)
102 def setPerpendicular (self, l1, l2):
103 """Sets perpendicular the two given lines and adds the corresponding constraint to this Sketch."""
104 constraint = self.my.addFeature("SketchConstraintPerpendicular")
105 constraint.data().refattr("ConstraintEntityA").setObject(l1)
106 constraint.data().refattr("ConstraintEntityB").setObject(l2)
109 def setDistance (self, point, line, length):
110 """Sets the distance between the given point and line, and adds the corresponding constraint to this Sketch."""
111 constraint = self.my.addFeature("SketchConstraintDistance")
112 if isinstance(line, str):
113 line = self.addLine(line).result() # Adds the edge identified by the given topological name to this Sketch
114 constraint.data().refattr("ConstraintEntityA").setAttr(point)
115 constraint.data().refattr("ConstraintEntityB").setObject(line)
116 constraint.data().real("ConstraintValue").setValue(length)
120 def setLength (self, line, length):
121 """Sets the length of the given line and adds the corresponding constraint to this Sketch."""
122 constraint = self.my.addFeature("SketchConstraintLength")
123 constraint.data().refattr("ConstraintEntityA").setObject(line)
124 constraint.data().real("ConstraintValue").setValue(length)
128 def setRadius (self, circle, radius):
129 """Sets the radius of the given circle and adds the corresponding constraint to this Sketch."""
130 constraint = self.my.addFeature("SketchConstraintRadius")
131 constraint.data().refattr("ConstraintEntityA").setObject(circle)
132 constraint.data().real("ConstraintValue").setValue(radius)
136 # Edition of Dimensional Constraints
138 def setValue (self, constraint, value):
139 """Modifies the value of the given dimensional constraint."""
140 constraint.data().real("ConstraintValue").setValue(value)
145 def selectFace (self, *args):
146 """Selects the geometrical entities of this Sketch on which the result Face must be built.
147 When no entity is given, the face is based on all existing geometry of this Sketch.
149 #self.resultype ="Face"
151 self.selection = modelAPI_ResultConstruction( self.my.firstResult() ).shape()
153 self.selection = args[0].shape()
155 raise Exception("not yet implemented")
158 def buildShape (self):
159 """Builds the result Shape of this Sketch according to the selected geometrical entities."""
160 o = geomDataAPI_Point( self.my.data().attribute("Origin") ).pnt()
161 dx = geomDataAPI_Dir( self.my.data().attribute("DirX") ).dir()
162 n = geomDataAPI_Dir( self.my.data().attribute("Norm") ).dir()
164 faces = ShapeList() # The faces are kept otherwise they are destroyed at exit
165 GeomAlgoAPI_SketchBuilder.createFaces(o, dx, n, self.selection, faces)
166 #TODO: Deal with several faces
170 """Returns the result data of this Feature."""
171 return self.my.firstResult()
174 # Class definitions of Sketch features
178 def __init__(self, sketch, x, y):
179 self.my = sketch.addFeature("SketchPoint")
180 geomDataAPI_Point2D( self.my.data().attribute("PointCoordindates") ).setValue(x, y)
183 def pointData (self):
184 return geomDataAPI_Point2D( self.my.data().attribute("PointCoordindates") )
187 return self.my.firstResult()
192 def __init__(self, sketch, *args):
193 self.my = sketch.addFeature("SketchLine")
195 self.__createByCoordinates(*args)
197 self.__createByPoints(*args)
199 self.__createByName(sketch, *args)
201 raise Exception("cannot create the Line")
203 def __createByCoordinates(self, x1, y1, x2, y2):
204 geomDataAPI_Point2D( self.my.data().attribute("StartPoint") ).setValue(x1, y1)
205 geomDataAPI_Point2D( self.my.data().attribute("EndPoint") ).setValue(x2, y2)
208 def __createByPoints(self, p1, p2):
209 geomDataAPI_Point2D( self.my.data().attribute("StartPoint") ).setValue(p1.x(), p1.y())
210 geomDataAPI_Point2D( self.my.data().attribute("EndPoint") ).setValue(p2.x(), p2.y())
213 def __createByName(self, sketch, name):
214 self.my.data().selection("External").selectSubShape("EDGE", name)
216 rigid = sketch.addFeature("SketchConstraintRigid")
217 rigid.refattr("ConstraintEntityA").setObject( self.my.firstResult() )
219 def startPointData (self):
220 return geomDataAPI_Point2D( self.my.data().attribute("StartPoint") )
222 def endPointData (self):
223 return geomDataAPI_Point2D( self.my.data().attribute("EndPoint") )
226 return self.my.firstResult()
231 def __init__(self, sketch, x, y, r):
232 self.my = sketch.addFeature("SketchCircle")
233 geomDataAPI_Point2D( self.my.data().attribute("CircleCenter") ).setValue(x, y)
234 self.my.data().real("CircleRadius").setValue(r)
237 def centerData (self):
238 return geomDataAPI_Point2D( self.my.data().attribute("CircleCenter") )
241 return self.my.lastResult() # Returns the circular line attribute