Jump to content

Manual: Creación de objetos paramétricos

From FreeCAD Documentation
Revision as of 16:40, 24 April 2026 by Desideratum (talk | contribs) (Created page with "{{Docnav |Creación y manipulación de geometría |Creación de herramientas de interfaz |Manual de inicio |IconC=Crystal Clear manual.png }}")

En el Capítulo anterior, exploramos cómo crear la geometría Pieza y visualizarla en pantalla adjuntándola a un objeto de documento "mudo" (no paramétrico). Si bien este método es efectivo, se vuelve engorroso cuando se necesita modificar la forma. Cada cambio requiere crear una nueva forma y reasignarla al objeto, lo que se traduce en flujos de trabajo repetitivos e ineficientes.

A lo largo de este manual, hemos visto cómo los objetos paramétricos abordan este problema permitiendo actualizaciones dinámicas. Al modificar una sola propiedad, la forma se recalcula automáticamente, eliminando la necesidad de actualizaciones manuales. Este proceso de recálculo permite un modelado más eficiente y aporta adaptabilidad a los diseños. Internamente, los objetos paramétricos funcionan de forma similar a lo que ya hemos visto: recalculan el contenido de su propiedad Forma cada vez que cambia una de sus propiedades. Este proceso iterativo es fluido y garantiza que el diseño del objeto se mantenga coherente con sus parámetros definidos.

FreeCAD ofrece un sistema fácil para crear objetos paramétricos completos usando Python. Estos objetos se definen mediante una clase de Python, que:

  • Declara las propiedades necesarias para el objeto.
  • Define el comportamiento cuando se modifica cualquiera de estas propiedades.

La estructura de un objeto paramétrico de este tipo es tan simple como esto:

class myParametricObject:

    def __init__(self, obj):
        obj.Proxy = self
        obj.addProperty("App::PropertyFloat", "MyLength")
        ...

    def execute(self,obj):
        print ("Recalculating the shape...")
        print ("The value of MyLength is:")
        print (obj.MyLength)
        ...

Todas las clases de Python suelen tener un método __init__. Este método se ejecuta cuando se instancia una clase, es decir, cuando se crea un objeto Python a partir de la clase. Se puede pensar en una clase como una "plantilla" o plano que se utiliza para crear instancias vivas de sí misma. Cada instancia de la clase se convierte en un objeto independiente con sus propios atributos y métodos. En nuestro método __init__, realizamos dos tareas cruciales:

Almacene la clase en el atributo Proxy del objeto de un documento de FreeCAD: Al asignar self al atributo Proxy del objeto de documento de FreeCAD, vinculamos la lógica de nuestra clase Python con el objeto de FreeCAD. Esto significa que el objeto de documento "contendrá" el código de la clase Python en su interior, lo que le permite comportarse según la lógica definida en la clase. Esta conexión permite a FreeCAD saber cómo interactuar con el objeto paramétrico y recalcularlo.

  • Cree todas las propiedades que necesite el objeto:

Mediante el método addProperty, definimos las propiedades personalizadas que requiere el objeto. Las propiedades actúan como parámetros o variables del objeto y se pueden acceder, modificar y visualizar en el editor de propiedades de FreeCAD. En el ejemplo, añadimos una propiedad de punto flotante llamada MyLength. Esta propiedad influirá posteriormente en la forma o el comportamiento del objeto.

FreeCAD ofrece una gran variedad de propiedades, desde números en coma flotante hasta cadenas de texto e incluso tipos especializados para geometría y materiales. Para explorar la lista completa de los tipos de propiedades disponibles, puede escribir el siguiente código en la consola de Python:

FreeCAD.ActiveDocument.addObject("Part::FeaturePython", "dummy").supportedProperties()

La segunda parte clave de nuestra clase es el método execute. Este método se activa automáticamente cuando el objeto se marca para recálculo, lo que ocurre al modificarse una de sus propiedades. En el método execute se realizan todos los recálculos del objeto, asegurando que su forma y comportamiento se actualicen para reflejar cualquier cambio. Dentro del método execute, se llevan a cabo todas las operaciones necesarias para generar la nueva geometría del objeto. Normalmente, esto implica recalcular la forma en función de los valores actuales de sus propiedades y, a continuación, asignar la forma actualizada al atributo Shape del objeto mediante una instrucción como obj.Shape = myNewShape. El método execute recibe un único argumento, obj, que representa el objeto del documento de FreeCAD asociado al objeto paramétrico. Esto permite manipular directamente el objeto dentro del método, por ejemplo, acceder a sus propiedades, actualizar su geometría o realizar otras operaciones.

En resumen:

  • El método execute se invoca siempre que sea necesario actualizar el objeto.
  • Este método se encarga de recalcular la forma y asignarla al atributo Shape del objeto.
  • El argumento obj proporciona acceso al objeto del documento de FreeCAD, lo que permite realizar cambios mediante programación.

Con este sistema, FreeCAD se encarga del resto, asegurando que el objeto se actualice correctamente en el documento y se muestre adecuadamente en la interfaz gráfica.

Es fundamental recordar que, al crear objetos paramétricos en un documento de FreeCAD, el código Python utilizado para definirlos no se guarda en el archivo. Esta es una medida de seguridad intencionada. Si se permitiera que los archivos de FreeCAD almacenaran código Python, se podría abrir la puerta a que personas malintencionadas distribuyeran archivos con scripts dañinos que podrían perjudicar el ordenador de alguien. Por lo tanto, al compartir un archivo de FreeCAD que contiene objetos paramétricos creados con código Python personalizado, el destinatario también debe tener acceso al código utilizado para definir dichos objetos. Sin él, FreeCAD no sabrá cómo recalcular ni interactuar correctamente con los objetos.

La forma más sencilla de garantizar esto es guardar el código Python en un archivo de macro. Al distribuir su archivo de FreeCAD, puede incluir la macro junto con él. Como alternativa, puede compartir la macro en el repositorio de macros de FreeCAD (Macros FreeCAD), permitiendo que otros la descarguen y utilicen fácilmente. Este método garantiza que tus objetos paramétricos personalizados sigan funcionando en otros sistemas, a la vez que se mantienen las mejores prácticas de seguridad.

A continuación, realizaremos un pequeño ejercicio: construir un objeto paramétrico que consiste en una simple cara rectangular paramétrica. Encontrará ejemplos más complejos en el ejemplo de objeto paramétrico y en el propio código fuente de FreeCAD.

Le daremos a nuestro objeto dos propiedades: Longitud y Anchura, que utilizaremos para construir un rectángulo. Luego, como nuestro objeto ya tendrá una propiedad de Posicionamiento predefinida (todos los objetos geométricos la tienen por defecto, no es necesario que la agreguemos nosotros mismos), desplazaremos el rectángulo a la posición/rotación establecida en la propiedad de posicionamiento, de modo que el usuario podrá mover el rectángulo a cualquier lugar editando dicha propiedad.

class ParametricRectangle:

    def __init__(self,obj):
        obj.Proxy = self
        obj.addProperty("App::PropertyFloat", "Length")
        obj.addProperty("App::PropertyFloat", "Width")

    def execute(self, obj):
        # We need to import the FreeCAD module here too, because we might be running out of the Console
        # (in a macro, for example) where the FreeCAD module has not been imported automatically:
        import FreeCAD
        import Part

        # First we need to make sure the values of Length and Width are not 0
        # otherwise Part.LineSegment will complain that both points are equal:
        if (obj.Length == 0) or (obj.Width == 0):
            # If yes, exit this method without doing anything:
            return

        # We create 4 points for the 4 corners:
        v1 = FreeCAD.Vector(0, 0, 0)
        v2 = FreeCAD.Vector(obj.Length, 0, 0)
        v3 = FreeCAD.Vector(obj.Length,obj.Width, 0)
        v4 = FreeCAD.Vector(0, obj.Width, 0)

        # We create 4 edges:
        e1 = Part.LineSegment(v1, v2).toShape()
        e2 = Part.LineSegment(v2, v3).toShape()
        e3 = Part.LineSegment(v3, v4).toShape()
        e4 = Part.LineSegment(v4, v1).toShape()

        # We create a wire:
        w = Part.Wire([e1, e2, e3, e4])

        # We create a face:
        f = Part.Face(w)

        # All shapes have a Placement too. We give our shape the value of the placement
        # set by the user. This will move/rotate the face automatically.
        f.Placement = obj.Placement

        # All done, we can attribute our shape to the object!
        obj.Shape = f

En lugar de pegar el código anterior en la consola de Python, es mejor guardarlo en algún lugar para poder reutilizarlo y modificarlo más adelante. Por ejemplo, en una nueva macro (menú Macro → Macros → Crear). Nómbrela, por ejemplo, ParamRectangle. Sin embargo, las macros de FreeCAD se guardan con la extensión .FCMacro, que Python no reconoce al usar la importación. Por lo tanto, antes de usar el código anterior, tendremos que cambiar el nombre del archivo ParamRectangle.FCMacro a ParamRectangle.py. Esto se puede hacer fácilmente desde el explorador de archivos, navegando a la carpeta Macros indicada en el menú Herramientas → Macros.

Una vez hecho esto, podemos hacerlo ahora en la consola de Python:

import ParamRectangle

Al explorar el contenido de ParamRectangle, podemos verificar que contiene nuestra clase ParametricRectangle.

Para crear un nuevo objeto paramétrico usando nuestra clase ParametricRectangle, utilizaremos el siguiente código. Observe que usamos Part::FeaturePython en lugar de Part::Feature, que hemos estado usando en los capítulos anteriores (la versión de Python permite definir nuestro propio comportamiento paramétrico):

myObj = FreeCAD.ActiveDocument.addObject("Part::FeaturePython", "Rectangle")
ParamRectangle.ParametricRectangle(myObj)
myObj.ViewObject.Proxy = 0 # This is mandatory unless we code the ViewProvider too.
FreeCAD.ActiveDocument.recompute()

Aquí tenéis un breve resumen de los comandos anteriores:

  • myObj = FreeCAD.ActiveDocument.addObject("Part::FeaturePython", "Rectangle"): Crea un nuevo objeto Part::FeaturePython llamado Rectangle en el documento FreeCAD activo. Este objeto está diseñado específicamente para un comportamiento paramétrico personalizado, lo que permite que la lógica definida en Python gestione sus propiedades y comportamiento.
  • ParamRectangle.ParametricRectangle(myObj): Inicializa el objeto asociándolo con la clase ParametricRectangle del módulo o script ParamRectangle. Esto vincula la lógica personalizada definida en Python con el objeto, lo que le permite actuar como un objeto paramétrico.
  • myObj.ViewObject.Proxy = 0: Restablece el atributo ViewObject.Proxy a 0, asegurando que el objeto utilice el manejo de vista predeterminado de FreeCAD. Este paso es necesario a menos que defina un ViewProvider personalizado para gestionar la representación visual del objeto.
  • FreeCAD.ActiveDocument.recompute(): Recalcula el documento para actualizar la geometría y reflejar los cambios en la interfaz gráfica de FreeCAD, haciendo que el nuevo objeto sea completamente visible y funcional.

Todavía no aparecerá nada en pantalla, ya que las propiedades Length y Width son 0, lo que activará nuestra condición de "no hacer nada" dentro de execute. Solo necesitamos cambiar los valores de Length y Width, y nuestro objeto aparecerá mágicamente y se recalculará sobre la marcha.

Por supuesto, sería tedioso tener que escribir estas 4 líneas de código Python cada vez que queramos crear un nuevo rectángulo paramétrico. Una forma muy sencilla de solucionarlo es colocar las 4 líneas anteriores dentro de nuestro archivo ParamRectangle.py, al final, después del final de la clase ParametricRectange (podemos hacerlo desde el editor de macros).

Ahora, cuando escribamos: import ParamRectangle, se creará automáticamente un nuevo rectángulo paramétrico. Mejor aún, podemos añadir un botón a la barra de herramientas que haga precisamente eso:

  • Abra el menú Herramientas → Personalizar
  • En la pestaña Macros, selecciona nuestra macro ParamRectangle.py, complete los detalles como desee y pulse Añadir:

  • En la pestaña Barras de Herramientas, cree una nueva barra de herramientas personalizada en el entorno de trabajo que prefiera (o globalmente), seleccione su macro y agréguela a la barra de herramientas:

  • Eso es todo, ahora tenemos un nuevo botón en la barra de herramientas que, al hacer clic, creará un rectángulo paramétrico.

Recuerde que, si quiere distribuir archivos creados con esta nueva herramienta a otras personas, ellas también deben tener instalada la macro ParamRectangle.py en sus ordenadores.

Leer más