SET(PYTHON_FILES
PythonFeaturesPlugin_Box.py
PythonFeaturesPlugin.py
+ sketch.py
+ extrusion.py
+ examples.py
+ SketchResult.py
)
SET(XML_RESSOURCES
--- /dev/null
+from ModelAPI import *
+from GeomDataAPI import *
+from GeomAlgoAPI import *
+
+# NOTE : I think this style should be chosen
+# for function as recommended by Python programming
+# standards
+def build_face_from_sketch (sketch, edges=None) :
+ # If no edges have been selected, get the whole sketch
+ # edges
+ if edges == None:
+ result = sketch.firstResult()
+ edges = modelAPI_ResultConstruction(result).shape()
+
+ # Build the face
+ origin = geomDataAPI_Point( sketch.attribute("Origin") ).pnt()
+ dirX = geomDataAPI_Dir( sketch.attribute("DirX") ).dir()
+ dirY = geomDataAPI_Dir( sketch.attribute("DirY") ).dir()
+ normal = geomDataAPI_Dir( sketch.attribute("Norm") ).dir()
+ faces = ShapeList()
+ GeomAlgoAPI_SketchBuilder.createFaces(origin, dirX, dirY, normal, edges, faces)
+ return faces[0]
+
+# NOTE : with an optional argument it is not
+# a so good idea to put part as last argument
+# it would result in a mandatory argument
+# put after an optionnal one
+def addExtrusion(part, sketch, size, reverse=False, subshapes=None):
+ feature = part.addFeature("Extrusion")
+
+ # Build apropriate face
+ face = build_face_from_sketch(sketch, subshapes)
+ # Get sketch result
+ sketchResult = sketch.firstResult()
+
+ # Set attributes and execute the feature
+ feature.selection("extrusion_face").setValue(sketchResult, face)
+ feature.real("extrusion_size").setValue(size)
+ feature.boolean("extrusion_reverse").setValue(False)
+ feature.execute()
+
+ return feature
import ModelAPI
+import examples
class PythonFeaturesPlugin_Box(ModelAPI.ModelAPI_Feature):
"Feature to create a box by drawing a sketch and extruding it"
aWidth = self.real(PythonFeaturesPlugin_Box.WIDTH_ID()).value()
aLength = self.real(PythonFeaturesPlugin_Box.LENGTH_ID()).value()
aHeight = self.real(PythonFeaturesPlugin_Box.HEIGHT_ID()).value()
- # print ("Box W:{0} L:{1} H:{2}".format(aWidth, aLength, aHeight))
- # aResult = document().createBody(data())
- # aResult.store(UserPackage.makeBox(aLength, aWidth, aHeight)
- # self.setResult(aResult)
-
-
-
+ print ("Box W:{0} L:{1} H:{2}".format(aWidth, aLength, aHeight))
+ aResultBody = self.document().createBody(self.data())
+ aResult = examples.makeBox(aLength, aWidth, aHeight)
+ #aShape = modelAPI_ResultConstruction(aResult).shape()
+ #aResultBody.store(aShape)
+ self.setResult(aResultBody)
+
+# TEST
+"""
+if __name__=='__main__':
+ session = ModelAPI.ModelAPI_Session.get()
+ part = session.activeDocument()
+ session.startOperation()
+ feature = part.addFeature('Box')
+ feature.real('box_width').setValue(10)
+ feature.real('box_length').setValue(10)
+ feature.real('box_height').setValue(10)
+ feature.execute()
+ session.finishOperation()
+"""
+
--- /dev/null
+from ModelAPI import *
+from GeomDataAPI import *
+from GeomAlgoAPI import *
+
+
+class SketchResult:
+
+ def __init__(self, sketch):
+ self.geom = sketch.firstResult()
+ self.faces = ShapeList()
+ self.edges = modelAPI_ResultConstruction(self.geom).shape()
+ self.origin = geomDataAPI_Point( sketch.attribute("Origin") ).pnt()
+ self.dirX = geomDataAPI_Dir( sketch.attribute("DirX") ).dir()
+ self.dirY = geomDataAPI_Dir( sketch.attribute("DirY") ).dir()
+ self.normal = geomDataAPI_Dir( sketch.attribute("Norm") ).dir()
+
+
+ def setEdges(self, edges):
+ self.edges = edges
+
+
+ def geometry(self):
+ return self.geom
+
+
+ def face(self):
+ GeomAlgoAPI_SketchBuilder.createFaces(self.origin, self.dirX, self.dirY, self.normal, self.edges, self.faces)
+ return self.faces[0]
\ No newline at end of file
--- /dev/null
+from ModelAPI import *
+import sketch
+import extrusion
+from SketchResult import *
+#reload(sketch) # Pour tester plus facilement
+#reload(extrusion) # Pour tester plus facilement
+
+def makeBox(aLength, aWidth, aHeight):
+ print "makeBox"
+ # Getting the active document
+
+ session = ModelAPI_Session.get()
+ part = session.activeDocument()
+
+
+ # Starting the Sketch
+
+ session.startOperation()
+ base = sketch.addTo(part)
+ sketch.setXOYPlane(base)
+
+
+ # Creating the lines
+
+ l1 = sketch.addLine(10, 10, 10, 50, base)
+ l2 = sketch.addLine(10, 50, 60, 60, base)
+ l3 = sketch.addLine(60, 60, 50, 10, base)
+ l4 = sketch.addLine(50, 10, 10, 10, base)
+
+
+ # Creating the constraints
+
+ # NOTE : the following lines are currently not working in BR_PYTHON_PLUGIN branch
+ """
+ sketch.makeCoincident(sketch.getEndPoint(l1), sketch.getStartPoint(l2), base)
+ sketch.makeCoincident(sketch.getEndPoint(l2), sketch.getStartPoint(l3), base)
+ sketch.makeCoincident(sketch.getEndPoint(l3), sketch.getStartPoint(l4), base)
+ sketch.makeCoincident(sketch.getEndPoint(l4), sketch.getStartPoint(l1), base)
+
+ sketch.makeParallel(sketch.getGeometry(l1), sketch.getGeometry(l3))
+ sketch.makeParallel(sketch.getGeometry(l2), sketch.getGeometry(l4))
+
+ sketch.makePerpendicular(sketch.getGeometry(l1), sketch.getGeometry(l4))
+ """
+
+ # Finalisation of the operation
+
+ builder = SketchResult(base)
+
+ # Creating a feature Extrusion
+ box = extrusion.addNew(builder, 50, part)
+ session.finishOperation()
+
+ #return base.lastResult()
+ return extrusion.getBody(box)
+
--- /dev/null
+from ModelAPI import *
+
+
+def addNew(builder, length, part, edges=None, reverse=False):
+ feature = part.addFeature("Extrusion")
+ feature.selection("extrusion_face").setValue(builder.geometry(), builder.face())
+ feature.real("extrusion_size").setValue(length)
+ feature.boolean("extrusion_reverse").setValue(reverse)
+ feature.execute()
+ return feature
+
+
+def getBody(extrusion):
+ return extrusion.firstResult()
\ No newline at end of file
--- /dev/null
+from ModelAPI import *
+from GeomDataAPI import *
+
+
+# Initialization of the Sketch
+# ----------------------------
+
+def addTo(doc):
+ return modelAPI_CompositeFeature( doc.addFeature("Sketch") )
+
+
+def setXOYPlane(sketch):
+ geomDataAPI_Point( sketch.attribute("Origin") ).setValue(0, 0, 0)
+ geomDataAPI_Dir( sketch.attribute("DirX") ).setValue(1, 0, 0)
+ geomDataAPI_Dir( sketch.attribute("DirY") ).setValue(0, 1, 0)
+ geomDataAPI_Dir( sketch.attribute("Norm") ).setValue(0, 0, 1)
+
+
+# Point geometry
+# --------------
+
+def addPoint(x, y, sketch):
+ point = sketch.addFeature("SketchPoint")
+ geomDataAPI_Point2D( point.attribute("PointCoordindates") ).setValue(x, y)
+ point.execute() #Required to get the result, if needed for creating constraints
+ return point
+
+
+def getGeometry(point):
+ return geomDataAPI_Point2D( point.attribute("PointCoordindates") )
+
+
+# Line geometry
+# -------------
+
+def addClosedBrokenLine(coords, sketch):
+ c0 = coords[0]
+ c1 = coords[1]
+ bl = []
+ l1 = sketch.addFeature("SketchLine")
+ geomDataAPI_Point2D( l1.attribute("StartPoint") ).setValue(c0.x(), c0.y())
+ geomDataAPI_Point2D( l1.attribute("EndPoint") ).setValue(c1.x(), c1.y())
+ l1.execute()
+ bl.append(l1)
+ l0 = l1
+
+ for c2 in coords[2:]:
+ l2 = sketch.addFeature("SketchLine")
+ geomDataAPI_Point2D( l2.attribute("StartPoint") ).setValue(c1.x(), c1.y())
+ geomDataAPI_Point2D( l2.attribute("EndPoint") ).setValue(c2.x(), c2.y())
+ l2.execute()
+ bl.append(l2)
+ constraint = sketch.addFeature("SketchConstraintCoincidence")
+ constraint.refattr("ConstraintEntityA").setAttr( l1.attribute("EndPoint") )
+ constraint.refattr("ConstraintEntityB").setAttr( l2.attribute("StartPoint") )
+ c1 = c2
+ l1 = l2
+
+ if len(coords) > 2:
+ l2 = sketch.addFeature("SketchLine")
+ geomDataAPI_Point2D( l2.attribute("StartPoint") ).setValue(c1.x(), c1.y())
+ geomDataAPI_Point2D( l2.attribute("EndPoint") ).setValue(c0.x(), c0.y())
+ l2.execute()
+ bl.append(l2)
+ constraint = sketch.addFeature("SketchConstraintCoincidence")
+ constraint.refattr("ConstraintEntityA").setAttr( l1.attribute("EndPoint") )
+ constraint.refattr("ConstraintEntityB").setAttr( l2.attribute("StartPoint") )
+
+ constraint = sketch.addFeature("SketchConstraintCoincidence")
+ constraint.refattr("ConstraintEntityA").setAttr( l2.attribute("EndPoint") )
+ constraint.refattr("ConstraintEntityB").setAttr( l0.attribute("StartPoint") )
+
+ return bl
+
+
+def addLine(x1, y1, x2, y2, sketch):
+ line = sketch.addFeature("SketchLine")
+ geomDataAPI_Point2D( line.attribute("StartPoint") ).setValue(x1, y1)
+ geomDataAPI_Point2D( line.attribute("EndPoint") ).setValue(x2, y2)
+ line.execute() #Required to get the result, if needed for creating constraints
+ return line
+
+
+def getGeometry(line):
+ return line.firstResult()
+
+
+def getStartPoint(line):
+ return geomDataAPI_Point2D( line.attribute("StartPoint") )
+
+
+def getEndPoint(line):
+ return geomDataAPI_Point2D( line.attribute("EndPoint") )
+
+
+# Constraints
+# -----------
+
+def makeCoincident(p1, p2, sketch):
+ constraint = sketch.addFeature("SketchConstraintCoincidence")
+ constraint.refattr("ConstraintEntityA").setAttr(p1)
+ constraint.refattr("ConstraintEntityB").setAttr(p2)
+
+
+def makeParallel(l1, l2, sketch):
+ constraint = sketch.addFeature("SketchConstraintParallel")
+ constraint.refattr("ConstraintEntityA").setObject(l1)
+ constraint.refattr("ConstraintEntityB").setObject(l2)
+
+
+def makePerpendicular(l1, l2, sketch):
+ constraint = sketch.addFeature("SketchConstraintPerpendicular")
+ constraint.refattr("ConstraintEntityA").setObject(l1)
+ constraint.refattr("ConstraintEntityB").setObject(l2)
