Scripted objects/es: Difference between revisions

From FreeCAD Documentation
(Created page with "== Haciendo objetos seleccionables == Si deseas hacer tu objeto seleccionable, o al menos parte de el, haciendo clic sobre el en el visor, debes incluir su geometría Coin d...")
(Created page with "Simplemente, se crea un nodo SoFCSelection, a continuación se le agregan los nodos de la geometría, y después lo añade a su nodo principal, en lugar de agregar los nodos d...")
Line 398: Line 398:
self.wireframe.addChild(selectionNode)
self.wireframe.addChild(selectionNode)
</syntaxhighlight>
</syntaxhighlight>
Simplemente, se crea un nodo SoFCSelection, a continuación se le agregan los nodos de la geometría, y después lo añade a su nodo principal, en lugar de agregar los nodos de geometría directamente.
Simply, you create a SoFCSelection node, then you add your geometry nodes to it, then you add it to your main node, instead of adding your geometry nodes directly.


== Working with simple shapes ==
== Working with simple shapes ==

Revision as of 21:53, 20 February 2014

Además de los tipos de objetos estándar, tales como anotaciones, mallas y objetos de pieza, FreeCAD también ofrece la estupenda posibilidad de construir objetos de archivos de guión hechos al 100% en Python, llamados Funcionalidades Python (Feature Python). Esos objetos se comportan exactamente como cualquier otro objeto de FreeCAD, y se guardar y restauran automáticamente al guardar o cargar archivos.

Debe comprenderse una particularidad, dichos objetos son guardados en archivos FcStd de FreeCAD con el módulo de Python cPickle. Este módulo devuelve un objeto de Python como una cadena de texto, permitiendo que se añada al guardado del archivo. En la carga, el módulo cPickle utiliza esa cadena de texto para recrear los objetos originales, proporcionándole acceso al código fuente que creó el objeto. Es decir que si guardas un objeto personalizado y lo abres en un ordenador en el que el código de Python que generó dicho objeto no está presente, el objeto no será recreado. Si distribuyes dichos objetos a otros usuarios, tendrás que distribuirlos junta al archivo de guión de Python que los crea.

Las Funcionalidades Python siguen las mismas reglas que todas las Funcionalidades de FreeCAD: se separan en las partes de App y GUI. La parte de App, el objeto documento, define la geometría de nuestro objeto, mientras que su parte GUI, el objeto proveedor de vistas, define el modo en que el objeto se dibujará en la pantalla. El objeto proveedor de vistas, como cualquier otra Funcionalidad de FreeCAD, sólo está disponible cuando se ejecuta FreeCAD en su propio GUI. Hay varias propiedades y métodos disponibles para construir tu objeto. Las propiedades tienen que ser de cualquiera de los tipos predefinidos de propiedades que ofrece FreeCAD, y aparecerá en la ventana de vista de propiedades, por lo que puede ser editado por el usuario. De esta manera, los objetos Funcionalidad Python son total y absolutamente paramétricos. Puedes definir las propiedades del objeto y de su ViewObject por separado.

Hint: In former versions we used Python's cPickle module. However, this module executes arbitrary code and thus causes a security problem. Thus, we moved to Python's json module.

Ejemplo básico

El ejemplo siguiente se puede encontrar en el archivo src/Mod/TemplatePyMod/FeaturePython.py , junto con varios otros ejemplos:

 "Examples for a feature class and its view provider."
 
 import FreeCAD, FreeCADGui
 from pivy import coin
 
 class Box:
 	def __init__(self, obj):
 		"'''Add some custom properties to our box feature'''"
 		obj.addProperty("App::PropertyLength","Length","Box","Length of the box").Length=1.0
 		obj.addProperty("App::PropertyLength","Width","Box","Width of the box").Width=1.0
 		obj.addProperty("App::PropertyLength","Height","Box", "Height of the box").Height=1.0
 		obj.Proxy = self
 	
 	def onChanged(self, fp, prop):
 		"'''Do something when a property has changed'''"
 		FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
  
 	def execute(self, fp):
 		"'''Do something when doing a recomputation, this method is mandatory'''"
 		FreeCAD.Console.PrintMessage("Recompute Python Box feature\n")
  
 class ViewProviderBox:
 	def __init__(self, obj):
 		"'''Set this object to the proxy object of the actual view provider'''"
 		obj.addProperty("App::PropertyColor","Color","Box","Color of the box").Color=(1.0,0.0,0.0)
 		obj.Proxy = self
  
 	def attach(self, obj):
 		"'''Setup the scene sub-graph of the view provider, this method is mandatory'''"
 		self.shaded = coin.SoGroup()
 		self.wireframe = coin.SoGroup()
 		self.scale = coin.SoScale()
 		self.color = coin.SoBaseColor()
  		
 		data=coin.SoCube()
 		self.shaded.addChild(self.scale)
 		self.shaded.addChild(self.color)
 		self.shaded.addChild(data)
 		obj.addDisplayMode(self.shaded,"Shaded");
 		style=coin.SoDrawStyle()
 		style.style = coin.SoDrawStyle.LINES
 		self.wireframe.addChild(style)
 		self.wireframe.addChild(self.scale)
 		self.wireframe.addChild(self.color)
 		self.wireframe.addChild(data)
 		obj.addDisplayMode(self.wireframe,"Wireframe");
 		self.onChanged(obj,"Color")
  
 	def updateData(self, fp, prop):
 		"'''If a property of the handled feature has changed we have the chance to handle this here'''"
 		# fp is the handled feature, prop is the name of the property that has changed
 		l = fp.getPropertyByName("Length")
 		w = fp.getPropertyByName("Width")
 		h = fp.getPropertyByName("Height")
 		self.scale.scaleFactor.setValue(l,w,h)
 		pass
  
 	def getDisplayModes(self,obj):
 		"'''Return a list of display modes.'''"
 		modes=[]
 		modes.append("Shaded")
 		modes.append("Wireframe")
 		return modes
  
 	def getDefaultDisplayMode(self):
 		"'''Return the name of the default display mode. It must be defined in getDisplayModes.'''"
 		return "Shaded"
  
 	def setDisplayMode(self,mode):
 		"'''Map the display mode defined in attach with those defined in getDisplayModes.\'''
                 '''Since they have the same names nothing needs to be done. This method is optional'''"
 		return mode
  
 	def onChanged(self, vp, prop):
 		"'''Here we can do something when a single property got changed'''"
 		FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
 		if prop == "Color":
 			c = vp.getPropertyByName("Color")
 			self.color.rgb.setValue(c[0],c[1],c[2])
  
 	def getIcon(self):
 		"'''Return the icon in XPM format which will appear in the tree view. This method is\'''
                 '''optional and if not defined a default icon is shown.'''"
 		return """
 			/* XPM */
 			static const char * ViewProviderBox_xpm[] = {
 			"16 16 6 1",
 			" 	c None",
 			".	c #141010",
 			"+	c #615BD2",
 			"@	c #C39D55",
 			"#	c #000000",
 			"$	c #57C355",
 			"        ........",
 			"   ......++..+..",
 			"   .@@@@.++..++.",
 			"   .@@@@.++..++.",
 			"   .@@  .++++++.",
 			"  ..@@  .++..++.",
 			"###@@@@ .++..++.",
 			"##$.@@$#.++++++.",
 			"#$#$.$$$........",
 			"#$$#######      ",
 			"#$$#$$$$$#      ",
 			"#$$#$$$$$#      ",
 			"#$$#$$$$$#      ",
 			" #$#$$$$$#      ",
 			"  ##$$$$$#      ",
 			"   #######      "};
 			"""
  
 	def __getstate__(self):
 		"'''When saving the document this object gets stored using Python's json module.\'''
                 '''Since we have some un-serializable parts here -- the Coin stuff -- we must define this method\'''
                 '''to return a tuple of all serializable objects or None.'''"
 		return None
  
 	def __setstate__(self,state):
 		"'''When restoring the serialized object from document we have the chance to set some internals here.\'''
                 '''Since no data were serialized nothing needs to be done here.'''"
 		return None
  
  
 def makeBox():
 	FreeCAD.newDocument()
 	a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box")
 	Box(a)
  	ViewProviderBox(a.ViewObject)

Propiedades disponibles

Las propiedades son las auténticas piedras de construcción de los objetos FeaturePython. A través de ellas, el usuario será capaz de interactuar y modificar su objeto. Después de crear un nuevo objeto FeaturePython en tu documento ( a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box") ), puedes obtener una lista de las propiedades disponibles escribiendo:

 obj.supportedProperties()

Obtendrás una lista de propiedades disponibles:

 App::PropertyBool
 App::PropertyFloat
 App::PropertyFloatList
 App::PropertyFloatConstraint
 App::PropertyAngle
 App::PropertyDistance
 App::PropertyInteger
 App::PropertyIntegerConstraint
 App::PropertyPercent
 App::PropertyEnumeration
 App::PropertyIntegerList
 App::PropertyString
 App::PropertyStringList
 App::PropertyLink
 App::PropertyLinkList
 App::PropertyMatrix
 App::PropertyVector
 App::PropertyVectorList
 App::PropertyPlacement
 App::PropertyPlacementLink
 App::PropertyColor
 App::PropertyColorList
 App::PropertyMaterial
 App::PropertyPath
 App::PropertyFile
 App::PropertyFileIncluded
 Part::PropertyPartShape
 Part::PropertyFilletContour
 Part::PropertyCircle

Cuando se añaden propiedades a tus objetos personalizados, ten en cuenta esto:

  • No utilices caracteres "<" o ">" en las descripciones de las propiedades (eso rompería las partes de xml en el archivo .fcstd)
  • Las propiedades se almacenan alfabéticamente en un archivo .fcstd. Si tienes una forma en tus propiedades, cualquier propiedad cuyo nombre va después de "Shape" en orden alfabético, se cargará DESPUÉS de la forma, lo que puede causar un comportamiento extraño.


Property Type

By default the properties can be updated. It is possible to make the properties read-only, for instance in the case one wants to show the result of a method. It is also possible to hide the property. The property type can be set using

  obj.setEditorMode("MyPropertyName", mode)

where mode is a short int that can be set to:

 0 -- default mode, read and write
 1 -- read-only
 2 -- hidden

Otro ejemplo más complejo

En este ejemplo se hace uso del Módulo de Pieza para crear un octaedro, a continuación, se crea su representación Coin con Pivy.

Lo primero es el propio objeto del documento:

 import FreeCAD, FreeCADGui, Part
 
    class Octahedron:
       def __init__(self, obj):
          "Add some custom properties to our box feature"
          obj.addProperty("App::PropertyLength","Length","Octahedron","Length of the octahedron").Length=1.0
          obj.addProperty("App::PropertyLength","Width","Octahedron","Width of the octahedron").Width=1.0
          obj.addProperty("App::PropertyLength","Height","Octahedron", "Height of the octahedron").Height=1.0
          obj.addProperty("Part::PropertyPartShape","Shape","Octahedron", "Shape of the octahedron")
          obj.Proxy = self
 
       def execute(self, fp):
          # Define six vetices for the shape
          v1 = FreeCAD.Vector(0,0,0)
          v2 = FreeCAD.Vector(fp.Length,0,0)
          v3 = FreeCAD.Vector(0,fp.Width,0)
          v4 = FreeCAD.Vector(fp.Length,fp.Width,0)
          v5 = FreeCAD.Vector(fp.Length/2,fp.Width/2,fp.Height/2)
          v6 = FreeCAD.Vector(fp.Length/2,fp.Width/2,-fp.Height/2)
          
          # Make the wires/faces
          f1 = self.make_face(v1,v2,v5)
          f2 = self.make_face(v2,v4,v5)
          f3 = self.make_face(v4,v3,v5)
          f4 = self.make_face(v3,v1,v5)
          f5 = self.make_face(v2,v1,v6)
          f6 = self.make_face(v4,v2,v6)
          f7 = self.make_face(v3,v4,v6)
          f8 = self.make_face(v1,v3,v6)
          shell=Part.makeShell([f1,f2,f3,f4,f5,f6,f7,f8])
          solid=Part.makeSolid(shell)
          fp.Shape = solid
 
       # helper mehod to create the faces
       def make_face(self,v1,v2,v3):
          wire = Part.makePolygon([v1,v2,v3,v1])
          face = Part.Face(wire)
          return face

después, conseguimos el objeto proveedor de vista, responsable de mostrar el objeto en la escena 3D:

    class ViewProviderOctahedron:
       def __init__(self, obj):
          "Set this object to the proxy object of the actual view provider"
          obj.addProperty("App::PropertyColor","Color","Octahedron","Color of the octahedron").Color=(1.0,0.0,0.0)
          obj.Proxy = self
 
       def attach(self, obj):
          "Setup the scene sub-graph of the view provider, this method is mandatory"
          self.shaded = coin.SoGroup()
          self.wireframe = coin.SoGroup()
          self.scale = coin.SoScale()
          self.color = coin.SoBaseColor()
 
          self.data=coin.SoCoordinate3()
          self.face=coin.SoIndexedLineSet()
 
          self.shaded.addChild(self.scale)
          self.shaded.addChild(self.color)
          self.shaded.addChild(self.data)
          self.shaded.addChild(self.face)
          obj.addDisplayMode(self.shaded,"Shaded");
          style=coin.SoDrawStyle()
          style.style = coin.SoDrawStyle.LINES
          self.wireframe.addChild(style)
          self.wireframe.addChild(self.scale)
          self.wireframe.addChild(self.color)
          self.wireframe.addChild(self.data)
          self.wireframe.addChild(self.face)
          obj.addDisplayMode(self.wireframe,"Wireframe");
          self.onChanged(obj,"Color")
 
       def updateData(self, fp, prop):
          "If a property of the handled feature has changed we have the chance to handle this here"
          # fp is the handled feature, prop is the name of the property that has changed
          if prop == "Shape":
             s = fp.getPropertyByName("Shape")
             self.data.point.setNum(6)
             cnt=0
             for i in s.Vertexes:
                self.data.point.set1Value(cnt,i.X,i.Y,i.Z)
                cnt=cnt+1
             
             self.face.coordIndex.set1Value(0,0)
             self.face.coordIndex.set1Value(1,1)
             self.face.coordIndex.set1Value(2,2)
             self.face.coordIndex.set1Value(3,-1)
 
             self.face.coordIndex.set1Value(4,1)
             self.face.coordIndex.set1Value(5,3)
             self.face.coordIndex.set1Value(6,2)
             self.face.coordIndex.set1Value(7,-1)
 
             self.face.coordIndex.set1Value(8,3)
             self.face.coordIndex.set1Value(9,4)
             self.face.coordIndex.set1Value(10,2)
             self.face.coordIndex.set1Value(11,-1)
 
             self.face.coordIndex.set1Value(12,4)
             self.face.coordIndex.set1Value(13,0)
             self.face.coordIndex.set1Value(14,2)
             self.face.coordIndex.set1Value(15,-1)
 
             self.face.coordIndex.set1Value(16,1)
             self.face.coordIndex.set1Value(17,0)
             self.face.coordIndex.set1Value(18,5)
             self.face.coordIndex.set1Value(19,-1)
 
             self.face.coordIndex.set1Value(20,3)
             self.face.coordIndex.set1Value(21,1)
             self.face.coordIndex.set1Value(22,5)
             self.face.coordIndex.set1Value(23,-1)
 
             self.face.coordIndex.set1Value(24,4)
             self.face.coordIndex.set1Value(25,3)
             self.face.coordIndex.set1Value(26,5)
             self.face.coordIndex.set1Value(27,-1)
 
             self.face.coordIndex.set1Value(28,0)
             self.face.coordIndex.set1Value(29,4)
             self.face.coordIndex.set1Value(30,5)
             self.face.coordIndex.set1Value(31,-1)
 
       def getDisplayModes(self,obj):
          "Return a list of display modes."
          modes=[]
          modes.append("Shaded")
          modes.append("Wireframe")
          return modes
 
       def getDefaultDisplayMode(self):
          "Return the name of the default display mode. It must be defined in getDisplayModes."
          return "Shaded"
 
       def setDisplayMode(self,mode):
          return mode
 
       def onChanged(self, vp, prop):
          "Here we can do something when a single property got changed"
          FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
          if prop == "Color":
             c = vp.getPropertyByName("Color")
             self.color.rgb.setValue(c[0],c[1],c[2])
 
       def getIcon(self):
          return """
             /* XPM */
             static const char * ViewProviderBox_xpm[] = {
             "16 16 6 1",
             "    c None",
             ".   c #141010",
             "+   c #615BD2",
             "@   c #C39D55",
             "#   c #000000",
             "$   c #57C355",
             "        ........",
             "   ......++..+..",
             "   .@@@@.++..++.",
             "   .@@@@.++..++.",
             "   .@@  .++++++.",
             "  ..@@  .++..++.",
             "###@@@@ .++..++.",
             "##$.@@$#.++++++.",
             "#$#$.$$$........",
             "#$$#######      ",
             "#$$#$$$$$#      ",
             "#$$#$$$$$#      ",
             "#$$#$$$$$#      ",
             " #$#$$$$$#      ",
             "  ##$$$$$#      ",
             "   #######      "};
             """
 
       def __getstate__(self):
          return None
 
       def __setstate__(self,state):
          return None

Por último, una vez que nuestro objeto y su viewobject están definidos, sólo nos falta invocarlos:

       FreeCAD.newDocument()
       a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Octahedron")
       Octahedron(a)
       ViewProviderOctahedron(a.ViewObject)

Haciendo objetos seleccionables

Si deseas hacer tu objeto seleccionable, o al menos parte de el, haciendo clic sobre el en el visor, debes incluir su geometría Coin dentro de un nodo SoFCSelection. Si el objeto tiene una representación compleja, con widgets, anotaciones, etc, puede que desees incluir sólo una parte de el en un SoFCSelection. Todo lo que es un SoFCSelection es constantemente explorado por FreeCAD para detectar selección/preselección, por lo que tiene sentido evitar sobrecargalo con innecesarias exploraciones. Esto es lo que se haría para incluir un self.face en el ejemplo anterior:

 selectionNode = coin.SoType.fromName("SoFCSelection").createInstance()
 selectionNode.documentName.setValue(FreeCAD.ActiveDocument.Name)
 selectionNode.objectName.setValue(obj.Object.Name) # here obj is the ViewObject, we need its associated App Object
 selectionNode.subElementName.setValue("Face")
 selectNode.addChild(self.face)
 ...
 self.shaded.addChild(selectionNode)
 self.wireframe.addChild(selectionNode)

Simplemente, se crea un nodo SoFCSelection, a continuación se le agregan los nodos de la geometría, y después lo añade a su nodo principal, en lugar de agregar los nodos de geometría directamente.

Working with simple shapes

If your parametric object simply outputs a shape, you don't need to use a view provider object. The shape will be displayed using FreeCAD's standard shape representation:

 class Line:
     def __init__(self, obj):
         '''"App two point properties" '''
         obj.addProperty("App::PropertyVector","p1","Line","Start point")
         obj.addProperty("App::PropertyVector","p2","Line","End point").p2=FreeCAD.Vector(1,0,0)
         obj.Proxy = self
 
     def execute(self, fp):
         '''"Print a short message when doing a recomputation, this method is mandatory" '''
         fp.Shape = Part.makeLine(fp.p1,fp.p2)
 
 a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","Line")
 Line(a)
 a.ViewObject.Proxy=0 # just set it to something different from None (this assignment is needed to run an internal notification)
 FreeCAD.ActiveDocument.recompute()
PyQt
Embedding FreeCAD