2. Summary
  3. Files
  4. Support
  5. Report Spam
  6. Create account
  7. Log in

Attention: this wiki is deactivated

The new wiki is up and running at http://www.freecadweb.org/wiki

Important: Do not edit this wiki anymore, it will be deleted soon. If you have edit rights here, please read this article to know how to regain your edit rights on the new wiki.

Manual/es

From free-cad

Jump to: navigation, search

Este es el manual de FreeCAD. Incluye las partes esenciales de la Wiki de documentación de FreeCAD. Está creado principalmente para ser impreso como un gran documento, de modo que, si lo estas leyendo online, posiblemente prefieras dirigirte directamente a la versión de la Ayuda en línea, que es más sencilla de manejar.

150


Bienvenido a la ayuda en línea de FreeCAD

Este documento ha sido creado automáticamente a partir del contenido de la documentación oficial FreeCAD wiki, que puede leerse en línea en http://apps.sourceforge.net/mediawiki/free-cad/index.php?title=Main_Page/es. Dado que el wiki es mantenido activamente, y está siendo continuamente desarrollado por la comunidad de desarrolladores y usuarios de FreeCAD, es posible que la versión en línea contenga más información o más reciente que este documento. Allí también encontrarás los procesos de traducción en marcha de esta documentación en diversos idiomas. Pero en todo caso, esperamos que encuentres aquí toda la información que necesites. En caso de tener preguntas que no encuentren respuestas en el presente documento, echa un vistazo en FreeCAD forum, donde tal vez puedas encontrar respuestas a tus preguntas, o a alguien capaz de ayudarte.


Cómo usar esta ayuda

Este documento se divide en varias secciones: introducción, uso, scripting (archivos de guión o secuencias de comandos) y desarrollo. Las tres secciones indicadas se dirigen específicamente a los tres grandes tipos de usuarios de FreeCAD: usuarios finales, que simplemente quieren usar el programa, los usuarios avanzados, que se interesan por las capacidades de scripting de FreeCAD y les gustaría personalizar algunos de sus aspectos, y los desarrolladores, que consideran FreeCAD como base para desarrollar sus propias aplicaciones. Si eres totalmente nuevo en FreeCAD, te sugerimos que simplemente empieces por la introducción.

Como Contribuir

Como habrás notado en ocasiones, los programadores no son buenos escritores de manuales de ayuda! Para ellos todo está bastante claro, aunque no esté suficientemente explicado (¡porque lo han hecho ellos mismos!). Por lo tanto es vital que los usuarios experimentados nos ayuden a escribir y revisar la documentación. Sí, lo decimos francamente!. ¿Y Cómo lo hago?, te preguntarás. Sólo tienes que ir a la Wiki http://apps.sourceforge.net/mediawiki/free-cad/index.php en la sección de usuario. Para entrar necesitarás una cuenta en sourceforge account, y solicita en los foros o en le canal de IRC permisos de escritura (la wiki está protegida contra escritura para evitar el spam). Después ya puedes empezar a editar! También comprueba la página Colabora con FreeCAD para ver cómo puedes contribuir con FreeCAD.

Traducciones disponibles:

Introducción

La Interfaz de FreeCAD

FreeCAD es una aplicación de modelado CAD 3D de propósito general. El desarrollo está completamente en Código abierto (Licencia GPL & LGPL). FreeCAD está orientado a la ingeniería mecánica y el diseño de producto pero también se ajusta a un amplio rango de usos cercanos a la ingeniería, como la arquitectura así como a otras especialidades de la ingeniería.

Las herramientas de FreeCAD son similares a las de Catia, SolidWorks o Solid Edge, por tanto también pertenece a la categoría de MCAD, PLM, CAx y CAE. Será un modelador paramétrico basado en operaciones con una arquitectura de software modular, que hace sencillo proporcionar funcionalidades adicionales sin modificar el sistema principal.

Como muchos de los modeladores 3D de CAD tendrá un componente 2D para extraer detalles de diseño a partir del modelo 3D y crear planos 2D de producción, pero el trabajar directamente en planos en 2D (como AutoCAD LT) no es el objetivo, tampoco lo es la animación o el diseño de formas orgánicas (como Maya, 3ds Max o Cinema 4D), aunque, gracias a su amplia adaptabilidad, FreeCAD podría llegar a ser útil en muchas otras áreas además de en la que está centrada actualmente.

Otra de las principales preocupaciones de FreeCAD es hacer un amplio empleo de todas las excelentes librerías de código abierto que existen en el campo de la Ciencia Computacional. Entre ellos se encuentra OpenCascade, un potente núcleo de CAD, Coin3D, una reencarnación de OpenInventor, Qt, la mundialmente famosa biblioteca multiplataforma para desarrollar interfaces gráficas, y Python, uno de los mejores lenguajes de archivos de guión disponibles. FreeCAD también puede utilizarse como una librería por otros programas.

FreeCAD es también completamente multiplataforma, y actualmente se ejecuta de forma impecable en Windows, Linux/Unix y Mac OSX, con exactamente el mismo aspecto y funcionalidades en todas las plataformas.

Echa un vistazo a la Lista de principales características o a los artículos the Primeros pasos, o diríjase directamente al Centro de usuarios!

Para comenzar con FreeCAD, continua con el siguiente artículo a través del proceso de instalación.

Traducciones disponibles:

Esta es una lista extensa (aunque incompleta) de las características que tiene FreeCAD. Si quieres saber que se incluirá en el futuro mira el Mapa de desarrollo. Para obtener una descripción rápida, un buen punto para empezar son las Capturas de pantalla.


Notas de la versión

Características generales

La Aplicación de Base

  • FreeCAD es multiplataforma. Se ejecuta y se comporta exactamente de la misma manera en Windows, Linux y Mac OSX.
  • FreeCAD es una completa aplicación de interfaz gráfica de usuario (GUI). FreeCAD cuenta con una completa interfaz gráfica de usuario basada en el famoso entorno Qt, con un visualizador 3D basado en Open Inventor, que permite un rápido renderizado de escenas 3D y una representación gráfica de escenas muy accesible.
  • FreeCAD también se ejecuta como una aplicación de línea de comandos, con menos requerimientos de memoria. En el modo de línea de comandos, FreeCAD se ejecuta sin su interfaz gráfica GUI, pero con todas sus herramientas de geometría. Puede ser, por ejemplo, utilizado como servidor para producir contenidos para otras aplicaciones.
  • FreeCAD puede ser importado como un módulo de Python, dentro de otras aplicaciones que puedan ejecutar scripts Python, o en una consola Python. Al igual que en modo consola, la parte de interfaz GUI de FreeCAD no está disponible, pero todas las herramientas de geometría son accesibles.
  • Implementa un sistema de carga tardía para el entramado de Plugins/Módulos y para las estructuras de datos. FreeCAD se divide en una aplicación principal y módulos, que se cargan sólo cuando es necesario. Casi todas las herramientas y elementos de geometría se almacenan en módulos. Los módulos se comportan como plugins, y se pueden agregar o eliminar en una instalación existente de FreeCAD.
  • Incorpora un sistema de gestión de archivos de guión en Python: FreeCAD cuenta con un intérprete Python interno, y una API que cubre casi cualquier parte de la aplicación, la interfaz, la geometría y la representación de esta geometría en el visualizador 3D. El intérprete puede ejecutar tanto comandos individuales como Archivos de guión (Scripts) complejos, de hecho en Python se pueden programar módulos completos para FreeCAD.
  • Un instalador MSI modular permite instalaciones flexibles en sistemas Windows. También se soportan paquetes para sistemas Ubuntu.


Estructura del documento

  • Entorno deshacer/Rehacer: Todas las acciones admiten los procesos deshacer/rehacer. Hay acceso al historial de acciones, de modo que en un solo paso se pueden deshacer múltiples acciones.
  • Gestión de transacciones: La pila del historial deshacer/rehacer almacena transacciones de documentos y no solo acciones individuales. Lo que permite definir exactamente lo que hay que deshacerse o rehacerse con cada herramienta.
  • Objetos de documento con asociación paramétrica: Todos los objetos en un documento FreeCAD puede ser definido por parámetros. Estos parámetros se pueden modificar sobre la marcha, y los objetos se vuelven a calcular en cualquier momento. La relación entre los objetos también se almacena, por lo que al modificar un objeto también se modifican sus objetos dependientes.
  • Guarda el documento en formato Compuesto (basado en ZIP): Los documentos guardados con FreeCAD con extensión .fcstd pueden contener muchos tipos diferentes de información, tales como la geometría, las secuencias de comandos o iconos en miniatura.


Interfaz de usuario

  • Interfaz gráfica de usuario (GUI) totalmente configurable/programable por medio de scripts. El interfaz de FreeCAD, basado en Qt es totalmente accesible a través del intérprete de Python. Aparte de las funciones simples que FreeCAD proporciona a los entornos de trabajo, todo el entorno Qt es también accesible, permitiendo cualquier operación desde la interfaz gráfica de usuario, tales como crear, agregar, acoplar, modificar o eliminar widgets y barras de herramientas.
  • concepto de entorno de trabajo (Workbench) : En la interfaz de FreeCAD, las herramientas se agrupan en entornos de trabajo (workbenchs). Esto permite mostrar sólo las herramientas utilizadas para llevar a cabo una cierta tarea, manteniendo el espacio de trabajo ordenado y acondicionado, y que la aplicación se cargue rápidamente.
  • Incorpora una consola de Python con resaltado de sintaxis, autocompletado y búscador (browser) de clases: Los comandos de Python pueden ser introducidos directamente en FreeCAD y los resultados aparecen de inmediato. Permitiendo que los programadores puedan probar la funcionalidad sobre la marcha, explorar el contenido de los módulos y aprender fácilmente sobre el funcionamiento interno de FreeCAD.
  • La interacción del usuario refleja "eco" en la consola: Todo lo que hace el usuario en la interfaz de FreeCAD ejecuta código python, que se puede ver en la consola y grabarse en macros.
  • Grabación y edición completa de macros: Los comandos Python emitidos cuando el usuario manipula la interfaz GUI se pueden grabar, editar si fuera necesario, y guardarlos para su reproducción posterior.
  • Miniaturas Thumbnailer (De momento solo en sistemas Linux): Los iconos de archivos de FreeCAD muestran el contenido del fichero en la mayoría de las aplicaciones de gestión de archivos, como por ejemplo el Nautilus de GNOME.


Características específicas de la aplicación

La funcionalidad de FreeCAD está dividida en módulos, cada uno dedicado a un tipo especial de datos y tareas:




Módulo de Mallas (Mesh)

  • El Módulo de Mallas se ocupa de las mallas 3D (meshes). Está destinado básicamente a la importación, adaptación y conversión a FreeCAD de las mallas generadas por otros programas, así como a la exportación en formato tipo malla de la geometría FreeCAD. Pero FreeCAD también cuenta con otros tipos de geometría mucho más avanzados que las mallas.
  • Creación de Primitivas (caja, esfera, cilindro, etc), "copia equidistante" (offset) (trivial o after Jung/Shin/Choi) o operaciones booleanas (unión, intersección, diferencia)
  • Exportar de los siguientes formatos: ASCII o binario STL (Stereo lithography format) (*.stl, *.ast), el formato OBJ (*.obj), soporte limitado de NASTRAN (*.nas, *.brl), mallas VRML (*.wrl), mallas nativas del kernel de FreeCAD (*.bms), mallas como módulo de Python (*.py)
  • Herramientas para chequeo y reparación de mallas: Prueba de conversión en sólido, detección de elementos duplicados, comprobación de auto-interseccion, relleno de huecos y orientacion uniforme.


Croquizado 2D

  • creación gráfica de elementos simples de geometría plana tales como líneas, curvas, rectángulos, arcos o círculos en cualquier plano del espacio 3D
  • Anotaciones como textos o cotas dimensionales
  • Operaciones de manipulación gráfica tales como desplazar, rotar, escalar, simetría, copia equidistante (offset) o conversión de formas, en cualquier plano del espacio 3D
  • Importar yExportar de los siguientes formatos: Autodesk's Drawing Exchange Format (*.dxf), formato Open Cad (*.oca, *.gcad) y SVG (*.svg)


CAD

An example of union, intersection and difference
  • Formas paramétricas primitivas como cajas, esferas, cilindros, conos o toros.
  • Componentes topológicos como vertices, bordes, contornos yplanos (por medio de programación en Python).
  • Modelado con extrusión o revolución, secciones yredondeos.
  • Importar yExportar en los siguientes formatos: STEP piezas y ensamblajes (*.stp,*.step), modelos IGES (*.igs, *.iges) y BRep (*.brp), el formato nativo de nuestro núcle de CAD Open CASCADE.


Módulo de Renderizado

  • El Módulo de renderizado permite exportar la geometría de FreeCAD a otros programas de renderizado para generar imagenes de alta calidad. De momento, solo está soportado POV-Ray. El módulo actualmente permite la creación de una hoja de render, y añadir geometría a esa hoja de render para exportar a un archivo de POV-Ray.


Módulo de Planos

  • El Módulo de Planos permite exportar vistas de la geometría 3D a un documento 2D SVG. Permite crear una hoja de dibujo a partir de una plantilla SVG existente, e incorporar vistas en esa hoja de dibujo. Posteriormente la hoja puede ser guardada como un archivo SVG.


Módulo de Mecanizado (CAM)

  • El Módulo de Mecanizado (CAM) está dedicado a tareas de mecanizado industrial, como el fresado. Este módulo está en una etapa de desarrollo inicial y, de momento está básicamente orientado al Conformado incremental. Aunque hay algunos algoritmos para planificación de trayectorias de mecanizado, aún no son operativos para el usuario final.


Traducciones disponibles:

Instalación

Instalación en Windows

El modo más sencillo de instalar FreeCAD en Windows es utilizar el instalador de abajo.

Image:Windows.png Windows 32-bit

Después de descargar el archivo .msi (Microsoft Installer), simplemente haz doble clic en él para iniciar el proceso de instalación.

Abajo hay más información sobre opciones técnicas. Si parece desalentador, no te preocupes! La mayoría de usuarios de Windows no necesitan más que el archivo .msi para instalar FreeCAD y dar sus primeros pasos started!

Instalación simple con el instalador de Microsoft

El modo más sencillo de instalar FreeCAD en Windows es utilizar el instalador de arriba. Esta página describe el uso y las características de Microsoft Installer para tener más opciones de instalación.

Si quieres descargar una versión de 64 bits o en desarrollo, mira la página de Descargas.

Instalación simple

El archivo de instalación de FreeCAD se suministra en formato .msi (Windows Installer).

Puedes descargar el último archivo .msi desde la Página oficial de descargas de FreeCAD. Después de descargar el archivo, simplemente haz doble clic en él para comenzar el proceso de instalación.

Instalación desde la línea de comandos

Con las utilidades del comando msiexec.exe, están disponibles características adicionales, como la instalación no interactiva y la instalación administrativa.

Instalación no interactiva

Con la línea de comandos 

 msiexec /i FreeCAD<version>.msi

la instalación se puede iniciar mediante programación. Se pueden pasar parámetros adicionales al final de esta línea de comandos, como 

 msiexec /i FreeCAD-2.5.msi TARGETDIR=r:\FreeCAD25

Interfaz de usuario limitada

La cantidad de interfaces de usuario que le instalador muestra puede controlarse con opciones /q, en particular:

  • /qn - Sin interfaz
  • /qb - Interfaz básica - simplemente un pequeño letrero de diálogo mostrando el progreso de la instalación
  • /qb! - Como /qb, pero ocultando el botón de cancelar
  • /qr - Interfaz reducida - Muestra todos los letreros de diálogo que no requieren interacción del usuario (evita todos los letreros de diálogo modales)
  • /qn+ - Como /qn, pero muestra el letrero de diálogo "Completed" al final
  • /qb+ - Como /qb, pero muestra el letrero de diálogo "Completed" al final

Directorio de destino

El directorio de destino correspondiente (TARGETDIR) determina el directorio raíz de la instalación de FreeCAD. Por ejemplo, se puede indicar una unidad de instalación deiferente con 

TARGETDIR=R:\FreeCAD25

El directorio de destino por defecto (TARGETDIR) es [WindowsVolume\Programm Files\]FreeCAD<version>.

Instalación para todos los usuarios

La adicción de 

 ALLUSERS=1

realiza la instalación para todos los usuarios. Por defecto, la instalación no interactiva instala la aplicación solo para el usuario actual, y la instalación interactiva muestra un letrero de diálogo que con la opción "para todos los usuarios" si el usuario actual tiene los permisos necesarios en Windows.

Selección de características

Un número de propiedades permite la selección de características a ser instaladas, reinstaladas, o eliminadas. El conjunto de características para el instalador de FreeCAD son

  • DefaultFeature - Instala el software adecuado, más las librerías principales
  • Documentation - Instala la documentación
  • Source code - Instala el código fuente
  • ... ToDo

Además, ALL especifica todas las características. Todas las características dependen de DefaultFeature, así que instalando cualquier característica automáticamente también se instala la característica por defecto. Las siguientes propiedades controlan las operaciones a ser instaladas o eliminadas

  • ADDLOCAL - Lista de características a ser instaladas en la máquina local
  • REMOVE - Lista de características a ser eliminadas
  • ADDDEFAULT - Lista de características añadidas en su configuración por defecto (la cual es local para todas las características de FreeCAD)
  • REINSTALL - Lista de características a ser reinstaladas/reparadas
  • ADVERTISE - Lista de características para las cuales realizar un anuncio de instalación

Hay algunas propiedades adicionales disponibles; mira la documentación del MSDN para más detalles.

Con estas opciones, añadiendo 

 ADDLOCAL=Extensions

instala el interprete y registra las extensiones, pero no instala nada más.

Desinstalación

Con 

 msiexec /x FreeCAD<version>.msi

se puede desinstalar FreeCAD. No es necesario disponer del archivo MSI para la desinstalación; alternativamente, el paquete o código del producto también puede ser especificado. Puedes encontrar el código del producto buscando en las propiedades del acceso directo de desinstalación que es instalado por FreeCAD en el menú de Inicio.

Instalación Administrativa

Con 

 msiexec /a FreeCAD<version>.msi

se puede iniciar una instalación "administrativa" (de red). Los archivos se descomprimen en el directorio de destino (que debería estar en un directorio en red), pero no se realiza ninguna otra modificación al sistema local. Además, se genera otro archivo mis (más pequeño) en el directorio de destino, cuyos clientes pueden utilizar para realizar una instalación local (Las futuras versiones podrán también ofrecer mantener algunas características completamente en la unidad de red).

Actualmente, no hay una interfaz de usuario para la instalación administrativa, de modo que el directorio de destino debe pasarse en la línea de comandos.

No existe un procedimiento específico de desinstalación para una instalación administrativa - simplemente eliminar el directorio de destino si ningún cliente ya no lo utiliza más.

Anuncios

Con 

 msiexec /jm FreeCAD<version>.msi

sería posible, en principio, "anunciar" FreeCAD a una máquina (con /ju para un usuario). Esto hará que los iconos aparezcan en el menú de inicio, y que las extensiones sean registradas, sin el software realmente instalado. El primer uso de una característica hará que dicha característica sea instalada.

El instalador de FreeCAD actualmente soporta simplemente los anuncios de las entradas en el menú de inicio, pero no los de los accesos directos.

Instalación automática en un grupo de máquinas

Con las políticas de grupo de Windows, es posible automáticamente instalar FreeCAD en un grupo de máquinas. Para hacerlo, hay que realizar los siguientes pasos:

  1. Acceder al controlador de dominio
  2. Copiar el archivo MSI en un directorio que esté compartido con acceso a todas las máquinas.
  3. Abrir el complemento MMC "Directorio activo de usuarios y ordenadores"
  4. Navegar hasta el grupo de ordenadores que necesitan FreeCAD
  5. Abrir las Propiedades
  6. Abrir las políticas de grupo
  7. Añadir una nueva política, y editarla
  8. En Configuración del ordenador/Instalación de software, seleccionar Nuevo/Paquete
  9. Seleccionar el archivo MSI a través de la ruta de red
  10. Opcionalmente, seleccionar que quieres que FreeCAD sea desinstalado si los ordenadores abandonan el alcance de la política.

La propagación de las políticas de grupo tipicamente lleva algo de tiempo - para deplegar el paquete de duentes fiables, todas las máquinas deberían reiniciarse.

Instalación en Linux utilizando Crossover Office

Puedes instalar la versión de Windows de FreeCAD en un sistema Linux utilizando CXOffice 5.0.1. Ejecuta msiexec desde la línea de comandos de CXOffice, asumiendo que el paquete de instalación está ubicado en el directorio "software" el cual tiene asignado a la unidad "Y:": 

msiexec /i Y:\\software\\FreeCAD<version>.msi

FreeCAD está ejecutándose, pero informará que la visualización de OpenGL no funcionará, como con otros programas ejecutándose bajo [Wine] Por ejemplo, [SketchUp].

Traducciones disponibles:

Instalación en Unix/Linux

La instalación de FreeCAD en los sistemas Linux más conocidos ha sido ahora aprobada por la comunidad, y FreeCAD debería estar disponible directamente a través del gestor de paquetes disponible en tu distribución. El equipo de FreeCAD también proporciona varios paquetes "oficiales" cuando las nuevas versiones están definidas, y un par de repositorios PPA experimentales para probar las últimass características que se están desarrollando.

Una vez tengas instalado FreeCAD, es hora de dar tus primeros pasos!

Ubuntu

FreeCAD está disponible desde los repositorios de Ubuntu desde la versión 9.04, y puede instalarse a través del Centro de Software o con: 

sudo apt-get install freecad

Alternativamente, la comunidad de FreeCAD proporciona un PPA con construcciones diarias. Este PPA es actualizado y construido automáticamente todos los días a partir de la última versión del código fuente, y por lo tanto contiene nuevas características como un máximo de un día de antigüedad, pero también puede contener regresiones (funcionalidad que deja de funcionar). Para añadir este PPA a tu lista de fuentes de software, haz: 

sudo add-apt-repository ppa:freecad-maintainers/freecad-daily
sudo apt-get update
sudo apt-get install freecad

La comunidad de FreeCAD también proporciona otro PPA, que es actualizado manualmente de vez en cuando , que es por tanto más estable: 

sudo add-apt-repository ppa:freecad-maintainers/freecad-dev
sudo apt-get update
sudo apt-get install freecad

Más información en la página de Descarga

Debian, Mint y otros sistemas basados en Debian

Desde Debian Lenny, FreeCAD está disponible directamente desde los repositorios de software de Debian y se puede instalar a través de Synaptic o simplemente con: 

sudo apt-get install freecad

OpenSUSE

FreeCAD se instala normalmente con: 

zypper install FreeCAD

Gentoo

FreeCAD se puede construir/instalar simplemente ejecutando: 

emerge freecad

Otros

Si averiguas que tu sistema incorpora FreeCAD pero no está incluido en esta página, por favor dínoslo en los foros!

Diversos paquetes de FreeCAD alternativos, no oficiales están disponibles en la red, por ejemplo para sistemas como Slackware o Fedora. Una búsqueda en la red puede darte rápidamente algunos resultados.

Instalación manual en sistemas basados en .deb

Si por cualquier razón no puedes utilizar los métodos de arriba, siempre puedes descargar uno de los paquetes .deb disponibles en la página de Descargas.

Image:Linux.png Ubuntu 32/64bit

Una vez descargues el .deb correspondiente a tu versión del sistema, si tienes el paquete Gdebi instalado (normalmente es así), simplemente necesitas navegar a donde esté to archivo descargado, y hacer doble clic en él. Las dependencias necesarias se cogerán automáticamente por tu sistema de gestión de paquetes. Alternativamente también puedes instalar desde el terminal, navegando a donde esté ubicado el archivo descargado, y escribiendo: 

sudo dpkg -i Name_of_your_FreeCAD_package.deb

cambiando Name_of_your_FreeCAD_package.deb por el nombre del archivo que has descargado.

Después de instalar FreeCAD, un icono de inicio se añadirá en la sección de "Gráficos" de tu menú de inicio.

Instalación en otros sistemas Linux/Unix

Por desgracia, hasta el momento, no está disponible ningún paquete precompilado para otros sistemas Linux/Unix, así que necesitaras compilar FreeCAD tu mismo.

Instalación de la versión para Windows en Linux

Mira la página de la Instalación para Windows.

Traducciones disponibles:

Instalación en Mac

FreeCAD puede instalarse en Mac OS X en un solo paso utilizando el instalador.
Image:Mac.png Mac OS X Lion 64-bit


Esta página describe el uso y las características del instalador de FreeCAD. También incluye instrucciones para su desinstalación. Una vez instalado, puedes dar tus primeros pasos!

Instalación simple

El instalador de FreeCAD se proporciona como un paquete de instalación (.mpkg) incluido en un archivo de imagen de disco.

Puedes descargar la última versión del instalador desde la página de Descargas. Después de descargar el archivo, simplemente monta la imagen del disco, y luego ejecuta el paquete Install FreeCAD.

File:mac_installer_1.png

El instalador te mostrará una pantalla de personalizar la instalación que lista los paquetes que serán instalados. Si sabes que ya tienes algunos de esos paquetes, puedes deseleccionarlos utilizando las casillas de selección. Si no estás segur, simplemente deja las casillas activadas.

File:mac_installer_2.png

Desinstalación

No existe actualmente un desinstalados para FreeCAD. Para eliminar por completo FreeCAD y todos los componentes instalados, arrastra los siguientes archivos y carpetas a la papelera:

  • En /Applications:
    • FreeCAD
  • En /Library/Frameworks/
    • SoQt.framework
    • Inventor.framework

Luego, desde el terminal, ejecuta: 

sudo /Developer/Tools/uninstall-qt.py
sudo rm -R /usr/local/lib/OCC
sudo rm -R /usr/local/include/OCC

Eso es todo. Tarde o temprano, FreeCAD estará disponible como un paquete de aplicación autocontenido de modo que se eliminarán todas estas molestias.

Traducciones disponibles:

Descubriendo FreeCAD

Novedades

Introducción

FreeCAD es una aplicación de modelado paramétrico CAD/CAE. Aún está en una fase inicial de desarrollo, así que no esperes poder utilizarlo de inmediato para entornos de producción. Pero si tienes curiosidad sobre el aspecto que tiene FreeCAD o qué características se están desarrollando en él, te invitamos a descargarlo y probarlo. Por el momento ya dispone de bastante funcionalidad, aunque todavía no tiene plenas facilidades para hacer cómoda ("amigable") la interacción con el usuario. Esto significa que si sabes un poco de Python, ya estarás en condiciones de producir y modificar una geometría compleja con relativa facilidad. En otro caso, probablemente encontrarás que FreeCAD todavía tiene algunas carencias para ti. Pero se paciente, se espera que esto cambie pronto.

Y si después de probarlo tienes comentarios, ideas u opiniones, por favor, comparte con nosotros en el Foro de discusión de FreeCAD!


Instalación

En primer lugar descarga (si no lo hiciste ya) e instala FreeCAD. Mira la página de Descargas de información acerca de las versiones y actualizaciones. Hay paquetes de instalación preparados para Windows (. Msi), Ubuntu y Debian (. Deb), openSUSE (. Rpm) y Mac OSX.


Explorando FreeCAD

La interfaz FreeCAD al iniciarlo por primera vez. Ver más capturas de pantalla.


FreeCAD es una aplicación de modelado 3D de propósito general, centrado en la ingeniería mecánica y otras áreas relacionadas, tales como otras especialidades de la ingeniería o la arquitectura. Se concibe como una plataforma para desarrollar cualquier tipo de aplicación 3D, así como también para realizar tareas muy específicas. Para ello, su interfaz está dividida en una serie de "entornos de trabajo" (workbench). Los entornos de trabajo permiten cambiar el contenido de la interfaz para visualizar únicamente las herramientas necesarias para una tarea específica, o un grupo de tareas.

La interfaz de FreeCAD puede ser descrita como un contenedor muy simple, con una barra de menús, un área de visualización 3D, y un par de paneles laterales para mostrar el contenido de la escena o las propiedades del objeto. Todo el contenido de estos paneles puede tener distinta apariencia, en función del "entorno de trabajo" (workbench) que se esté usando.

Al iniciar FreeCAD por primera vez, se presentará un entorno de trabajo "general", que llamaremos "entorno de trabajo completo". Este entorno de trabajo simplemente contiene las herramientas más significativas de otros entornos de trabajo. Como FreeCAD es bastante joven y aún no se utiliza para trabajos muy especializados, este entorno de trabajo "completo" puede ser muy útil para descubrir FreeCAD con mayor facilidad. Básicamente, todas las herramientas que son lo suficientemente buenas para la producción de la geometría están aquí.


Navegando en el espacio 3D

FreeCAD tiene tres diferentes Modos de navegación disponibles, que se pueden establecer en las preferencias del diálogo de configuración o cambiar pulsando el botón derecho en la vista 3D. Para ver más detalles sobre los modos mira la página Modos de navegación. Para el modo de navegación por defecto ("Navegación CAD"), los comandos son los siguientes

Select Pan Zoom Rotate View
Image:Hand_cursor.png Image:Pan_cursor.png Image:Zoom_cursor.png Image:Rotate_cursor.png
to Select to Pan to Zoom in or out to Rotate view
Press the left mouse button over an object you want to select. Holding down ctrl allows the selection of multiple objects. Click the middle mouse button and move the object around to pan Use the mouse wheel to zoom in and out. Click first with the middle mouse button, hold it and the click the left mouse button on any visible part of an object and drag it in the desired direction. This works like spinning a ball that rotates around its center. If you release the buttons before you stop your motion, the object continues spinning, if this is enabled. A double click with the middle mouse button on any part of an object sets the new center of rotation and zooms in on this point.

También tiene varias vistas preconfiguradas (vista superior, vista frontal, etc.) disponibles en el menú Ver y en la barra de herramientas Ver y, por atajos numéricos (1, 2, etc...)

Image:Workbench_Draft.png Croquizado 2D

Dibujando objetos

Estas son las herramientas para crear objetos.

  • Image:Draft_Line.png Línea de 2 puntos: Dibuja un segmento de línea entre 2 puntos
  • Image:Draft_Wire.png Polilínea (Línea de múltiples puntos): Dibuja una polilínea compuesta por múltiples segmentos de línea
  • Image:Draft_Circle.png Circunferencia: Dibuja una circunferencia a partir de su centro y radio
  • Image:Draft_Arc.png Arco: Dibuja un segmento de arco a partir de su centro, radio ángulo de inicio y ángulo final
  • Image:Draft_Rectangle.png Rectángulo: Dibuja un rectángulo a partir de 2 puntos de su diagonal
  • Image:Draft_Polygon.png Polígono: Dibuja un polígono regular a partir del centro y radio de la circunferencia que lo circunscribe
  • Image:Draft_BSpline.png BSpline: Dibuja una B-Spline a partir de una serie de puntos
  • Image:Draft_Text.png Texto: Dibuja una anotación de múltiples líneas de texto
  • Image:Draft_Dimension.png Cota: Dibuja una cota dimensional
  • Punto: Inserta un objeto punto

Modificando objetos

Estas son las herramientas para la edición de los objetos existentes. Trabajan sobre los objetos seleccionados, pero si no hay ningún objeto seleccionado, permiten seleccionar uno.

  • Image:Draft_Move.png Desplazar: Desplaza objeto(s) desde una ubicación a otra
  • Image:Draft_Rotate.png Girar: Gira objeto(s) desde un ángulo de inicio a un ángulo final
  • Image:Draft_Offset.png Equidistancia: Mueve segmentos de un objeto a cierta distancia
  • Image:Draft_Upgrade.png Promocionar: Une objetos en un objeto de nivel superior
  • Image:Draft_Downgrade.png Degradar: Descompone objetos en objetos de nivel inferior
  • Image:Draft_Trimex.png Recortar/Extender: Recorta o extiende un objeto
  • Image:Draft_Scale.png Escalar: Escala los objetos seleccionados alrededor de un punto base
  • Image:Draft_Edit.png Editar: Edita un objeto seleccionado
  • Image:Draft_PutOnSheet.png Dibujar: Escribe los objetos seleccionados en una Hoja de dibujo
  • Image:Draft_Shape2DView.png Shape 2D View: Crea un objeto 2D que es la vista 2D proyectada de otro objeto 3D
  • Contorno a BSpline: Convierte un contorno a BSpline y viceversa
  • Añadir punto: Añade un punto a un contorno o una BSpline
  • Borrar punto: Borra un punto de un contorno o BSpline
  • Boceto a croquis: Convierte un objeto de Boceto a Croquis y viceversa
  • Matriz: Crea una matriz polar o rectangular a partir de los objetos seleccionados
  • Clonar: Clona los objetos seleccionados

Herramientas de utilidad

Herramientas adicionales disponibles desde el menú contextual del botón derecho del ratón, dependiendo de los objetos seleccionados.


Image:Workbench_Part.png Creando Piezas 3D

Primitivas

Estas son las herramientas para crear primitivas de objetos.

  • Caja: Dibuja una caja especificando sus dimensiones
  • Cono: Dibuja un cono especificando sus dimensiones
  • Cilindro: Dibuja un cilindro especificando sus dimensiones
  • Esfera: Dibuja una esfera especificando sus dimensiones
  • Toro: Dibuja un toro (anillo) especificando sus dimensiones

Modificando objetos

Estas son las herramientas para modificar los objetos existentes. Permiten seleccionar los objetos a modificar.

  • Operaciones Booleanas: Realiza operaciones Booleanas sobre los objetos
  • Fusión: Fusión (unión) de dos objetos
  • Intersección: Extrae la parte común (intersección) de dos objetos
  • Diferencia: Corta (resta) un objeto de otro
  • Extrusión: Extruye caras planas de un objeto
  • Redondear: Redondea las aristas de un objeto
  • Revolución: Crea un objeto haciendo que gire otro objeto alrededor de un eje
  • Sección: Crea una sección por la intersección de un objeto con un plano de sección
  • Chaflán: Crea un chaflán en las aristas de un objeto
  • Simetría: Crea una simetría de los objetos seleccionados alrededor de un plano de simetría dado


Exportando a Dibujos 2D

Estas son las herramientas para la creación, configuración y exportación de hojas de dibujo 2D


Exportando a programas de renderizado externos

Estas son las herramientas para exportar tu trabajo 3D a aplicaciones de renderizado externas


Programación de archivos de guión

Y finalmente, una de las características más poderosas de FreeCAD es el entorno de Programación de archivos de guión. Desde la consola integrada de Python (o desde cualquier otro archivo de guión de Python), puedes acceder a casi cualquier parte de FreeCAD, crear o modificar geometría, modificar la representación de esos objetos en la escena 3D o acceder y modificar la interfaz de FreeCAD. Los archivos de guión de Python también pueden utilizarse en Macros, las cuales proporcionan un método sencillo de crear comandos personalizados.


Traducciones disponibles:

Trabajando con FreeCAD

Navegación 3D

The FreeCAD mouse model consists of the commands used to visually navigate the 3D space and interact with the objects displayed. There are currently 3 different mouse navigation schemes in FreeCAD. The default navigation style is referred to as "CAD Navigation," and is very simple and practical, but FreeCAD also has two alternative navigation styles modeled after Inventor and Blender navigation.

Navigation

La manipulación de objetos es común a todos los entornos de trabajo. Las siguientes acciones del ratón se pueden utilizar para controlar la posición y visualización de los objetos de acuerdo con el estilo de navegación que esté seleccionado.

Hay dos formas de cambiar el estilo de navegación:

  • En el Editor de Preferencias, sección Display, pestaña Vista 3D;
  • Pulsando con el botón derecho en un área vacía de la vista 3D y seleccionando Estilo de navegación en el menú contextual.

Navegación CAD (por defecto)

Este es el estilo de navegación por defecto y permite al usuario un control simple de la vista, y no requiere el uso del teclado con la excepción de la realización de selecciones múltiples.

Selección Encuadre Zoom Rotar vista
Image:Hand_cursor.png Image:Pan_cursor.png Image:Zoom_cursor.png Image:Rotate_cursor.png
Selección Encuadre Zoom Rotar vista
Presiona el botón izquierdo sobre el objeto que quieras seleccionar. Manteniendo pulsadas la tecla CRTL se permite la selección de múltiples objetos. Pulsa el botón del medio. Utiliza la rueda del ratón para acercar o alejar la vista. Pulsa primero con el botón del medio, mantén el botón presionado y pulsa el botón izquierdo sobre cualquier parte visible de cualquier pieza de un objeto y arrástralo en la dirección deseada. Esto funciona como si se girase una bola que rotase sobre su centro. Si liberas el botón antes de parar el movimiento, el objeto continua girando, si está activado. Un doble clic con el botón del medio sobre cualquier parte de un objeto establece en ese punto el nuevo centro de rotación y acerca la vista a él.

Navegación de Inventor

En la Navegación de Inventor, no se puede seleccionar sólo con el ratón. Para seleccionar objetos, debes mantener presionada la tecla CTRL.

Selección Encuadre Zoom Rotar vista
Image:Hand_cursor.png Image:Pan_cursor.png Image:Zoom_cursor.png Image:Rotate_cursor.png
ctrl +para seleccionar para encuadrar para hacer Zoom in o Zoom out o para hacer Zoom in o Zoom out para Rotar la vista
Manten pulsado CTRL y presiona el botón izquierdo del ratón sobre un objeto que quieras seleccionar. Pulsa el botón izquierdo del ratón y mover cerca del objeto. Utiliza la rueda del ratón para hacer zoom in y zoom out, o pulsa y manten presionado el botón central y pulsa el botón izquierdo del ratón. Pulsa y arrastra con el botón izquierdo para rotar la vista

Navegación de Blender

En la Navegación de Blender, no se puede hacer un encuadre sólo con el ratón. Para hacer un encuadre, debes mantener presionada la tecla SHIFT.

Selección Encuadre Zoom Rotar vista
Image:Hand_cursor.png Image:Pan_cursor.png Image:Zoom_cursor.png Image:Rotate_cursor.png
Selección shift+Encuadre Zoom Rotar vista
Presiona el botón izquierdo del ratón sobre el objeto que quieras seleccionar. Mantén presionada la tecla de mayúsculas (shift) y pulsa el botón del medio del ratón. Utiliza la rueda del ratón para alejar o acercar la vista. Pulsa y arrastra con el botón del medio del ratón.

Seleccionando objetos

Los objetos pueden seleccionarse mediante un clic con el botón izquierdo del ratón o bien pulsando sobre el objeto en la vista 3D o seleccionándolo en la vista en árbol. También hay un mecanismo de preselección que resalta los tobjetos y muestra información de ellos antes de seleccionarlos con sólo pasar el ratón sobre ellos. Si no te gusta ese comportamiento o si tienes una máquina lenta, puedes desactivar la opción de preselección en el menú de preferencias.

Manipulación de Objetos

FreeCAD ofrece manipuladores que se pueden utilizar para modificar un objeto o su aspecto visual. Un ejemplo sencillo es el plano de recorte, que se puede activar con el menú Ver --> Plano de recorte. Después de la activación, el objeto plano de recorte aparece, y se muestran siete manipuladores con aspecto de cajitas o recuadros. Algunos manipuladores tienen un manejo obvio: Uno en cada extremo de sus tres ejes de coordenadas y otro en el centro del plano eje normal. Hay cuatro más que no son tan obvios: El plano, propiamente, y la parte delgada de los tres objetos eje.

Escala
Para escalar el objeto, haz clic con el botón izquierdo del ratón sobre los manipuladores al final de los ejes y tira de ellos hacia atrás y adelante. Dependiendo del objeto, los manipuladores trabajan independientemente o de forma sincronizada.
desplazamiento Fuera de plano
Para desplazar el objeto a lo largo de su vector normal, tira del recuadro grande en el centro de un eje con el botón izquierdo del ratón. En el caso del plano de recorte no hay más que un manipulador en el vector normal.
desplazamiento En el plano
Para mover el centro del plano de recorte, haga clic en el objeto plano y tire de él hasta la posición deseada.
Rotación
Al hacer clic en la parte delgada de los ejes del manipulador, se activa el modo de rotación.

Soporte de Hardware

FreeCAD también soporta algún Dispositivo de entrada 3D.

Traducciones disponibles:

El documento de FreeCAD

Un documento FreeCAD contiene todos los objetos de la escena. Puede contener grupos y objetos hechos con cualquier entorno de trabajo. Por lo tanto, puedes cambiar entre los entornos de trabajo, y seguir trabajando en el mismo documento. El documento es lo que se guarda en el disco al guardar tu trabajo. También puedes abrir varios documentos al mismo tiempo en FreeCAD, y abrir varias vistas del mismo documento.

En el documento, los objetos se pueden mover e incorporar a grupos, y cada objeto tiene un nombre único, exclusivo. La gestión de grupos, objetos y nombres de objeto se hace principalmente en la vista de árbol. También se puede hacer, por supuesto, como todo en FreeCAD, desde el intérprete de Python. En la vista de árbol, se pueden crear grupos, mover objetos a grupos, eliminar objetos o grupos,... haciendo clic con el botón derecho del ratón en la vista en árbol o en un objeto, cambiar el nombre de los objetos haciendo doble clic sobre sus nombres,... o posiblemente otras operaciones, en función del entorno de trabajo actual.

Los objetos dentro de un documento FreeCAD pueden ser de diferentes tipos. Cada entorno de trabajo puede crear sus propios tipos de objetos, por ejemplo, el Entorno de trabajo de mallas crea objetos de malla, el Entorno de trabajo de piezas crear objetos de piezas, el Entorno de croquizado 2D también crea objetos Parte, etc

Si hay uno o más documentos abiertos en FreeCAD, siempre alguno de ellos, y sólo uno, será el documento activo. Ese es el documento que aparece en la vista 3D actual, el documento con el que se está trabajando actualmente.

Aplicación e interfaz de usuario

Como casi todo lo demás en FreeCAD, la interfaz de usuario (GUI) del entorno de trabajo de piezas está separada de la aplicación base de piezas. Esto también es válido para los documentos. Los documentos también están hechos de dos partes: el documento de la aplicación, que contiene nuestros objetos, y el documento Vista, que contiene la representación en pantalla de nuestros objetos.

Piensa en ello como dos espacios, donde los objetos están definidos. Sus parámetros constructivos (¿es un cubo? ¿Un cono? ¿Qué tamaño? ...) se almacenan en el documento de aplicación, mientras que su representación gráfica (¿es dibujado con línea negra? ¿Con las caras azules? ...) se almacena en el documento Vista. ¿Por qué? Porque FreeCAD también puede ser utilizado sin interfaz gráfica, por ejemplo dentro de otros programas y, aún así, tenemos que ser capaces de manipular nuestros objetos, incluso si no se dibujan en la pantalla.

Otra cosa que está contenida en el documento Vista son las vistas 3D. Un documento puede tener varias vistas abiertas, así que puedes inspeccionar tu documento desde varios puntos de vista al mismo tiempo. Tal vez te gustaría ver una vista superior y una vista frontal de tu trabajo, al mismo tiempo. De ese modo, tendrías dos puntos de vista del mismo documento, ambos almacenados en el documento Vista. Crear puntos de vista nuevos o cerrar vistas se puede hacer desde el menú Vista o haciendo clic derecho en la pestaña de una vista.


Archivos de guión

Los documentos se pueden crear fácilmente, acceder y modificar desde el intérprete de Python. Por ejemplo: 

FreeCAD.ActiveDocument

devolverá el documento activo actual 

FreeCAD.ActiveDocument.Blob

accedería a un objeto llamado "Blob" dentro de tu documento 

FreeCADGui.ActiveDocument

devolvería el documento vista asociado al documento actual 

FreeCADGui.ActiveDocument.Blob

accedería a la parte representación gráfica (vista) de nuestro objeto Blob 

FreeCADGui.ActiveDocument.ActiveView

devolverá la vista actual


Traducciones disponibles:

Definiendo las preferencias de usuario

Las preferencias del sistema de FreeCAD se encuentra en el menú Editar -> Preferencias.

La funcionalidad de FreeCAD está dividida en diferentes módulos, cada módulo se hace cargo del funcionamiento de un determinado Entorno de trabajo. FreeCAD también utiliza un concepto llamado carga tardía, lo que significa que los componentes se cargan sólo cuando se necesitan. Habrás notado que, cuando se selecciona un entorno de trabajo en la barra de herramientas de FreeCAD, tanto el entorno como todos sus componentes se cargan en ese momento. Esto incluye la configuración de tus preferencias.

Image: Screenshot_preferences01.jpg

La configuración de las preferencias generales

Cuando se inicia FreeCAD sin un entorno de trabajo cargado, la ventana de preferencias mostrará un contenido mínimo. A medida que se cargan módulos adicionales, en la ventana de preferencias aparecerán nuevas secciones, lo que permite configurar los detalles de cada entorno de trabajo.

Sin ningún módulo cargado, tendrás acceso a dos secciones de configuración, las correspondientes a la configuración general de la aplicación y a la configuración de la visualización en pantalla.

Image: Screenshot_preferences02.jpg

La configuración de la visualización en pantalla

FreeCAD está siempre en constante evolución, por lo que el contenido de sus letreros de diálogo puede diferir de las capturas de pantalla mostradas arriba. En general, los ajustes se explican por sí mismos. Por ello no deberías tener dificultades en adaptar la configuración de FreeCAD a tus necesidades.


Traducciones disponibles:

Personalizando la interfaz

Como la interfaz de FreeCAD se basa en el moderno toolkit Qt, su diseño es de última generación. Los Widgets, menús, barras de herramientas y demás elementos se pueden modificar, mover o compartir entre los diversos entornos de trabajo. Se puede establecer métodos abreviados de teclado, cambiarlos, y se pueden grabar y reproducir macros. Para acceder a la ventana de personalización se usa el menú Herramientas -> Personalizar:

Image:Screenshot-customize.jpg


La pestaña Comandos permite explorar todos los comandos de FreeCAD disponibles, organizados por categorias.

En Teclado, se pueden ver los atajos de teclado, o combinaciones rápidas de teclas, asociadas con cada comando de FreeCAD y, si se desea, modificar o asignar nuevas combinaciones a cualquier comando. Por ejemplo podrías utilizarlo si utilizas frecuentemente un entorno de trabajo concreto y deseas agilizar su uso con el teclado.

Las pestañas de Barras de herramientas y Toolbox bars permiten modificar las barras de herramientas existentes o crear tus propias barras de herramientas a medida.

La pestaña Macros te permite manejar las Macros que tengas guardadas.

Traducciones disponibles:

Propiedades de objetos

Una propiedad es un pedazo de información, tal como un número o una cadena de texto, que se adjunta a un documento de FreeCAD o a un objeto en un documento. Las propiedades pueden ser vistas y modificadas (sólo si tienes permisos para ello) con el Editor de propiedades.

Las Propiedades juegan un papel muy importante en FreeCAD, ya que el programa fue concebido desde el principio para trabajar con objetos paramétricos, que son objetos definidos únicamente por sus propiedades.

En FreeCAD, los Archivos de guión para crear objetos personalizados por el usuario pueden tener propiedades de los siguientes tipos: 


Boolean
Float
FloatList
FloatConstraint
Angle
Distance
Integer
IntegerConstraint
Percent
Enumeration
IntegerList
String
StringList
Link
LinkList
Matrix
Vector
VectorList
Placement
PlacementLink
Color
ColorList
Material
Path
File
FileIncluded
PartShape
FilletContour
Circle


Traducciones disponibles:

Trabajando con los entornos

FreeCAD, al igual que muchas aplicaciones de diseño moderno, como [Revit] o [Catia], se basa en el concepto de entorno de trabajo. Un entorno de trabajo (o banco de trabajo) puede describirse como un conjunto de herramientas especialmente agrupadas para facilitar una determinada tarea. En un taller de muebles tradicionales, podríamos tener una mesa de trabajo para la persona que trabaja con madera, otra para el que trabaja con piezas de metal, y quizás una tercera para el individuo que monta todas las piezas juntas.

En FreeCAD se aplica el mismo concepto. Las herramientas se agrupan en entornos de trabajo de acuerdo con las tareas a las que se vinculan.

Actualmente tenemos disponibles los siguientes entornos de trabajo:

Hay nuevos entornos de trabajo en proceso de desarrollo, mantente atento!

Al cambiar de un entorno de trabajo a otro, las herramientas disponibles en el interfaz de usuario cambian. Las Barras de herramientas, barras de comandos y eventualmente otras partes de la interfaz cambian con el nuevo entorno de trabajo, aunque el contenido de la escena permanece inalterado. Podrías, por ejemplo, empezar a dibujar formas en 2D con el entorno de boceto, y después seguir trabajando sobre ellas con el entorno de Piezas.


Traducciones disponibles:

El entorno de Malla

El entorno de mallas maneja mallas triangulares. Las mallas son un tipo especial de objeto 3D, compuesto por triángulos conectados por sus bordes y sus esquinas (también llamados vértices).


An example of a mesh object

Un ejemplo de un objeto malla


Muchas aplicaciones 3D usan mallas como su objeto 3D básico, como sketchup, blender, maya o 3d studio max. Dado que las mallas son objetos muy simples, que contiene sólo los vértices (puntos), los bordes y las caras (triangulares), son muy fáciles de crear, modificar, dividir, estirar, y fácilmente se puede pasar de una aplicación a otra sin ningún tipo de pérdida. Además, ya que contienen datos muy sencillos, las aplicaciones 3D pueden manejar gran cantidad de mallas sin ningún problema. Por estas razones, las mallas son a menudo el tipo de objeto 3D de elección preferente en aplicaciones de tratamiento de películas, animación y creación de imágenes.

Sin embargo, en el ámbito de la ingeniería las mallas presentan una gran limitación: Son objetos muy básicos, sólo se compone de puntos, líneas y caras. Sólo están formados por superficies, y no tienen información de masas, por lo que no se comportan como sólidos. En una malla no hay forma directa de saber si un punto está dentro o fuera del objeto. Esto significa que todas las operaciones basadas en sólidos, como uniones o diferencias, son siempre un poco difíciles de realizar en mallas, y a menudo se producen errores.

Como FreeCAD es una aplicación de ingeniería, es evidente que preferimos trabajar con tipos de objetos 3D más "completos" ( o "inteligentes"), que puedan incorporar más información, tales como la masa, el comportamiento de sólidos, o incluso parámetros personalizados. El módulo de malla fue inicialmente creado para servir como "banco de pruebas", pero al ser capaz de leer, manipular y convertir mallas es también muy importante para FreeCAD. Muy a menudo, en tu flujo de trabajo, recibirás los datos 3D en formato de malla. Tendrás que manejar esos datos, analizarlos para detectar errores u otros problemas que impiden convertirlos en objetos más inteligentes, y, por último, convertirlos en esos objetos "más inteligentes", que podrán ser manejados por el Entorno de piezas.

Usando el módulo de Mallas

El módulo de mallas tiene actualmente una interfaz muy sencilla, todas sus funciones se agrupan en la entrada de menú Malla. Las operaciones más importantes que actualmente se puede hacer con las mallas son:

  • Importar Mallas en varios formatos de archivo
  • Exportar mallas en varios formatos de archivo
  • Convertir objetos Piezas en mallas
  • Analizar la curvatura, caras y comprobar si una malla puede convertirse con seguridad en un sólido
  • Invertir las normales de las mallas
  • Tapar agujeros en la malla
  • Quitar caras de la malla
  • Unión, intersección y diferencia de mallas
  • Crear mallas primitivas, como cubos, esferas, conos o cilindros
  • Cortar la malla a lo largo de una línea


Estas son sólo algunas de las operaciones básicas que en la actualidad están presentes en la interfaz del módulo de malla. Pero las mallas FreeCAD también pueden ser manejadas de muchas otras formas con archivos de guión.



Traducciones disponibles:

El entorno de Pieza

Las capacidades CAD de FreeCAD se basan en el núcleo de OpenCasCade. El módulo de Piezas permite a FreeCAD utilizar y acceder a los objetos y funciones de OpenCascade. OpenCascade es un núcleo de CAD de nivel profesional, que cuenta con avanzadas capacidades de manipulación de geometría 3D y objetos. Los objetos Pieza, en contraste con los objetos Malla, son mucho más complejos y, por tanto, permiten operaciones mucho más avanzadas, como operaciones booleanas coherentes, historial de modificaciones y comportamiento paramétrico.

Image:Part example.jpg

Ejemplo de entidades Pieza en FreeCAD

Contents


Las herramientas

Las herramientas del módulo Pieza están todas situadas en el menú Pieza, que aparece cuando se carga el módulo Piezas.

Primitivas

Estas son las herramientas para crear primitivas de objetos.

  • Caja: Dibuja una caja especificando sus dimensiones
  • Cono: Dibuja un cono especificando sus dimensiones
  • Cilindro: Dibuja un cilindro especificando sus dimensiones
  • Esfera: Dibuja una esfera especificando sus dimensiones
  • Toro: Dibuja un toro (anillo) especificando sus dimensiones

Modificando objetos

Estas son las herramientas para modificar los objetos existentes. Permiten seleccionar los objetos a modificar.

  • Operaciones Booleanas: Realiza operaciones Booleanas sobre los objetos
  • Fusión: Fusión (unión) de dos objetos
  • Intersección: Extrae la parte común (intersección) de dos objetos
  • Diferencia: Corta (resta) un objeto de otro
  • Extrusión: Extruye caras planas de un objeto
  • Redondear: Redondea las aristas de un objeto
  • Revolución: Crea un objeto haciendo que gire otro objeto alrededor de un eje
  • Sección: Crea una sección por la intersección de un objeto con un plano de sección
  • Chaflán: Crea un chaflán en las aristas de un objeto
  • Simetría: Crea una simetría de los objetos seleccionados alrededor de un plano de simetría dado

Operaciones Booleanas

An example of union (Fuse), intersection (Common) and difference (Cut)

Un ejemplo de unión (Fusión), intersección (Común) y diferencia (Quita)


Explicando conceptos

En la terminología OpenCascade, distinguimos entre primitivas geométricas y formas (topológicas). Una primitiva geométrica puede ser un punto, una línea, un círculo, un plano, etc, o incluso algunos tipos más complejos como una superficie o una curva B-Spline. Una forma puede ser un vértice, un borde, un alambre, una cara, un sólido o un compuesto de otras formas. Las primitivas geométricas no están hechas para ser visualizadas directamente en la escena 3D, sino que se utilizarán para la construcción de la geometría de las formas. Por ejemplo, un borde (forma, shape) puede construirse a partir de una línea o de un arco de círculo (primitivas).

Podríamos decir, para resumir, que las primitivas geométricas son bloques de construcción "inmateriales" (abstractos, "sin forma"), y las formas son la verdadera geometría espacial ("materializada") construida sobre ellas.

Para obtener una lista completa de todos ellos puedes ir a OCC documentation (Alternativa: sourcearchive.com) y búscar Geom_* (para la geometría) yTopoDS_* (para las formas). Allí también se puede leer más acerca de las diferencias entre las formas y los objetos geométricos. Ten en cuenta que, lamentablemente, la documentación oficial de OCC no está disponible en línea (se debe descargar un archivo) y está dirigida básicamente a los programadores, no a los usuarios finales. Pero posiblemente puedas encontrar allí información suficiente para iniciarse en esto.

Los tipos geométricos en realidad se puede dividir en dos grandes grupos: las curvas y superficies. A partir de las curvas (líneas, círculos, ...) se puede construir un borde, a partir de las superficies (plano, cilindro, ...) se puede construir una cara. Por ejemplo, la primitiva geométrica línea es ilimitada, es decir, se define por un vector de base y un vector de dirección, mientras que su representación como forma será algo limitado por un punto de inicio y otro de fin. Y, de modo similar, una caja - un sólido - puede ser creada con seis planos limitados.

A partir de un borde o una cara (formas) también se puede pasar a su contraparte como primitiva geométrica.

Así, a partir de las formas se pueden crear piezas muy complejas o, al revés, se pueden extraer todas las sub-formas de las que está hecha otra forma más compleja.



Archivos de guión

La estructura de datos más utilizada en el módulo de Piezas es el Tipo BRep de OpenCascade. Prácticamente todos los contenidos y los tipos de objeto del módulo de Piezas ya están disponibles para los archivos de guión con Python . Esto incluye primitivas geométricas, tales como la Línea y el Círculo (o arco), y toda la gama de TopoShapes, como vértices, bordes, alambres, caras, sólidos y compuestos. Cada uno de esos objetos puede ser creado de varios modos, y para algunos de tales objetos, especialmente los TopoShapes, también son posibles operaciones avanzadas, como la unión/diferencia/intersección booleana. Explore el contenido del módulo de Piezas, como se describe en la página Conceptos básicos de archivos de guión en FreeCAD, para saber más.

Ejemplos

Para crear un elemento línea pasa a la consola de Python y escribe: 

import Part,PartGui 
doc=App.newDocument()  
l=Part.Line()
l.StartPoint=(0.0,0.0,0.0)
l.EndPoint=(1.0,1.0,1.0)
doc.addObject("Part::Feature","Line").Shape=l.toShape() 
doc.recompute()

Vamos a ver paso a paso el anterior ejemplo en Python: 

import Part,PartGui
doc=App.newDocument()

Carga el módulo de piezas y crea un nuevo documento 


l=Part.Line()
l.StartPoint=(0.0,0.0,0.0)
l.EndPoint=(1.0,1.0,1.0)

Line es, de hecho, un segmento de recta, por ello la asignación de los puntos de inicio y fin. 


doc.addObject("Part::Feature","Line").Shape=l.toShape()

Esto añade un objeto del tipo pieza al documento y le asigna la forma de representación del segmento de línea a la propiedad 'Forma' del objeto agregado. Es importante entender aquí que se utilizó una primitiva geométrica (el Part.line) para crear un TopoShape a partir de la misma (el método toShape () ). En el documento sólo se pueden añadir formas. En FreeCAD, las primitivas geométricas se utilizan como "estructuras de soporte" para las formas. 


doc.recompute()

Actualiza el documento. Esto también prepara la representación visual del nuevo objeto Parte.


Ten en cuenta que una línea se pueden crear especificando sus puntos de inicio y final directamente en el constructor, por ejemplo . Part.Line (punto1, punto2) o podemos crear una línea predeterminada y establecer sus propiedades después, como lo hicimos aquí.


Podemos crear un círculo de modo similar: 

import Part
doc = App.activeDocument()
c = Part.Circle() 
c.Radius=10.0  
f = doc.addObject("Part::Feature", "Circle")
f.Shape = c.toShape()
doc.recompute()


Observa de nuevo: Se utilizó el círculo (primitiva geométrica) para construir una forma a partir de él. Por supuesto, después podemos seguir teniendo acceso a la geometría de nuestra construcción, haciendo: 

s = f.Shape
e = s.Edges[0]
c = e.Curve

Aquí tomamos la forma de nuestro objeto f, después tomamos la lista de los bordes, en este caso sólo habrá uno porque hemos hecho toda la forma a partir de un solo círculo, así que tomamos sólo el primer elemento de la lista de bordes, y tomamos su curva. Cada borde tiene una curva, que es la primitiva geométrica en la que se sustenta.

Diríjete a la página Archivos de guión de topología de datos si quieres saber más.


Traducciones disponibles:

El entorno de Dibujo

El módulo de Dibujo te permite poner en papel tu trabajo 3D. Es decir, sirve para poner vistas de tus modelos en una ventana 2D e insertar esas ventanas en un dibujo, por ejemplo una hoja con un formato, un título y tu logotipo y, finalmente, imprimir esa hoja. El módulo de Dibujo está en desarrollo y es más o menos una muestra de sus posibilidades!


Herramientas GUI

Estas son las herramientas para la creación, configuración y exportación de hojas de dibujo 2D


En la imagen se ven los principales elementos del módulo de Dibujo. El documento contiene un objeto forma (Schenkel) que queremos poner en papel. Para ello creamos una "Página". Una página se crea a partir de una plantilla, en este caso la plantilla "A3_apaisado". La plantilla es un documento SVG que puede contener la disposición habitual de tus dibujos, tu logotipo o los estándares que utilices.

En la página puedes insertar una o varias vistas. Cada vista tiene una posición en la página (Propiedades X, Y), un factor de escala (Propiedad escala) y propiedades adicionales. Cada vez que la página, o la vista, o el objeto referenciado cambia, la página se regenera y la visualización de la página se actualiza.


Archivos de guión

De momento, el interfaz (GUI) para el usuario final está poco desarrollado, por lo que los archivos de guión de la API son más interesantes. A continuación veremos ejemplos de cómo utilizar los archivos de guión de la API del módulo de Dibujo.

Ejemplo Simple

Lo primero, se necesitan los módulos Parte y Drawing: 

import FreeCAD, Part, Drawing

Creamos una pequeña Pieza, como muestra 

Part.show(Part.makeBox(100,100,100).cut(Part.makeCylinder(80,100)).cut(Part.makeBox(90,40,100)).cut(Part.makeBox(20,85,100)))

Proyección directa. G0 significa borde en arista, y G1 es continuidad de tangencia. 

Shape = App.ActiveDocument.Shape.Shape
[visibleG0,visibleG1,hiddenG0,hiddenG1] = Drawing.project(Shape)
print "visible edges:", len(visibleG0.Edges)
print "hidden edges:", len(hiddenG0.Edges)

Todo se proyecta sobre el plano Z: 

print "Bnd Box shape: X=",Shape.BoundBox.XLength," Y=",Shape.BoundBox.YLength," Z=",Shape.BoundBox.ZLength
print "Bnd Box project: X=",visibleG0.BoundBox.XLength," Y=",visibleG0.BoundBox.YLength," Z=",visibleG0.BoundBox.ZLength

Vector de proyección diferente 

[visibleG0,visibleG1,hiddenG0,hiddenG1] = Drawing.project(Shape,App.Vector(1,1,1))

Projectar a SVG 

resultSVG = Drawing.projectToSVG(Shape,App.Vector(1,1,1))
print resultSVG

En modo paramétrico

Se Crea la pieza 

# Crea 3 cajas y un cilindro
App.ActiveDocument.addObject("Part::Box","Box")
App.ActiveDocument.Box.Length=100.00
App.ActiveDocument.Box.Width=100.00
App.ActiveDocument.Box.Height=100.00

App.ActiveDocument.addObject("Part::Box","Box1")
App.ActiveDocument.Box1.Length=90.00
App.ActiveDocument.Box1.Width=40.00
App.ActiveDocument.Box1.Height=100.00

App.ActiveDocument.addObject("Part::Box","Box2")
App.ActiveDocument.Box2.Length=20.00
App.ActiveDocument.Box2.Width=85.00
App.ActiveDocument.Box2.Height=100.00

App.ActiveDocument.addObject("Part::Cylinder","Cylinder")
App.ActiveDocument.Cylinder.Radius=80.00
App.ActiveDocument.Cylinder.Height=100.00
App.ActiveDocument.Cylinder.Angle=360.00

# Unión de 2 cajas y el cilíndro
App.activeDocument().addObject("Part::Fuse","Fusion")
App.activeDocument().Fusion.Base = App.activeDocument().Cylinder
App.activeDocument().Fusion.Tool = App.activeDocument().Box1

App.activeDocument().addObject("Part::Fuse","Fusion1")
App.activeDocument().Fusion1.Base = App.activeDocument().Box2
App.activeDocument().Fusion1.Tool = App.activeDocument().Fusion

# Eliminar los elementos unidos anteriormente con la primera caja
App.activeDocument().addObject("Part::Cut","Shape")
App.activeDocument().Shape.Base = App.activeDocument().Box
App.activeDocument().Shape.Tool = App.activeDocument().Fusion1

# Ocultar todas las formas intermedias 
Gui.activeDocument().Box.Visibility=False
Gui.activeDocument().Box1.Visibility=False
Gui.activeDocument().Box2.Visibility=False
Gui.activeDocument().Cylinder.Visibility=False
Gui.activeDocument().Fusion.Visibility=False
Gui.activeDocument().Fusion1.Visibility=False

Inserta un objeto página (Page object), y le asigna una plantilla 

App.activeDocument().addObject('Drawing::FeaturePage','Page')
App.activeDocument().Page.Template = App.getResourceDir()+'Mod/Drawing/Templates/A3_Landscape.svg'

Crea una vista del objeto "forma", define la posicion y la escala, y la asigna a la Página 

App.activeDocument().addObject('Drawing::FeatureViewPart','View')
App.activeDocument().View.Source = App.activeDocument().Shape
App.activeDocument().View.Direction = (0.0,0.0,1.0)
App.activeDocument().View.X = 10.0
App.activeDocument().View.Y = 10.0
App.activeDocument().Page.addObject(App.activeDocument().View)

Crea una segunda vista del mismo objecto, pero esta vez la vista está girada 90 grados. 

App.activeDocument().addObject('Drawing::FeatureViewPart','ViewRot')
App.activeDocument().ViewRot.Source = App.activeDocument().Shape
App.activeDocument().ViewRot.Direction = (0.0,0.0,1.0)
App.activeDocument().ViewRot.X = 290.0
App.activeDocument().ViewRot.Y = 30.0
App.activeDocument().ViewRot.Scale = 1.0
App.activeDocument().ViewRot.Rotation = 90.0
App.activeDocument().Page.addObject(App.activeDocument().ViewRot)

Crea una tercera vista del mismo objeto, pero en proyección isométrica. Se activa también la ocultación de líneas. 

App.activeDocument().addObject('Drawing::FeatureViewPart','ViewIso')
App.activeDocument().ViewIso.Source = App.activeDocument().Shape
App.activeDocument().ViewIso.Direction = (1.0,1.0,1.0)
App.activeDocument().ViewIso.X = 335.0
App.activeDocument().ViewIso.Y = 140.0
App.activeDocument().ViewIso.ShowHiddenLines = True
App.activeDocument().Page.addObject(App.activeDocument().ViewIso)

Cambiamos algo, y actualizamos. Se regenera la vista y la página. 

App.activeDocument().View.X = 30.0
App.activeDocument().View.Y = 30.0
App.activeDocument().View.Scale = 1.5
App.activeDocument().recompute()

Accediendo a los datos y las partes

Obtiene el fragmento de SVG de una sola vista 

ViewSVG = App.activeDocument().View.ViewResult
print ViewSVG

Obtiene la página de resultados completa (Es un archivo en el directorio de archivos temporales, con permisos de solo lectura) 

print "Resulting SVG document: ",App.activeDocument().Page.PageResult
file = open(App.activeDocument().Page.PageResult,"r")
print "Result page is ",len(file.readlines())," lines long"

Importante: Liberar el archivo! 

del file

Inserta una vista con tu propio contenido: 

App.activeDocument().addObject('Drawing::FeatureView','ViewSelf')
App.activeDocument().ViewSelf.ViewResult = """<g id="ViewSelf"
  stroke="rgb(0, 0, 0)"
  stroke-width="0.35"
  stroke-linecap="butt"
  stroke-linejoin="miter"
  transform="translate(30,30)"
  fill="#00cc00"
  >

  <ellipse cx="40" cy="40" rx="30" ry="15"/>
  </g>
"""
App.activeDocument().Page.addObject(App.activeDocument().ViewSelf)
App.activeDocument().recompute()

del Shape,ViewSVG, resultSVG

Eso da como resultado lo siguiente:

Plantillas

FreeCAD viene con un juego de plantillas básico, pero se pueden obtener más en la página Drawing templates/es.


Traducciones disponibles:

El entorno de Renderizado

Este módulo está destinado a trasladar el contenido de la escena a un Programa de renderizado externo, para la generación de imágenes fotorrealistas de tu trabajo. El módulo Raytracing (de trazado de rayos) se encuentra todavía en fase muy temprana de elaboración, así que por ahora no tiene muchas opciones disponibles. De momento, sólo está implementado un conjunto básico de herramientas para exportar objetos Piezas como archivos POV-ray. Los archivos pueden ser cargados en POV-ray y renderizados.


Herramientas GUI

Estas son las herramientas para exportar tu trabajo 3D a aplicaciones de renderizado externas


Exportar una Vista

La manera mas fácil es exportar la vista 3D actual y todo su contenido a un archivo de Povray. Primero, se debe crear o cargar un modelo CAD y definir la orientación deseada para la vista 3D. Despues, elegir "Exportar Vista..." en el menú Renderizado.

Pedirá un sitio para guardar el archivo *.pov resultante. Despues, ya se podrá abrir el fichero en Povray y renderizar:

Image:Povray.jpg

Como es normal en un programa de renderizado, se pueden lograr magníficas imágenes:

Archivos de guión

Veamos ahora como usar esas herramientas desde Python: 

import Raytracing,RaytracingGui
OutFile = open('C:/Documents and Settings/jriegel/Desktop/test.pov','w')
OutFile.write(open(App.getResourceDir()+'Mod/Raytracing/Templates/ProjectStd.pov').read())
OutFile.write(RaytracingGui.povViewCamera())
OutFile.write(Raytracing.getPartAsPovray('Box',App.activeDocument().Box.Shape,0.800000,0.800000,0.800000))
OutFile.close()
del OutFile

Enlaces

Sobre POV-Ray:

Actualmente existe un nuevo entorno de renderizado en desarrollo para soportar múltiples back-ends de renderizado como Lux y Yafaray. Puedes ver información para utilizar la versión en desarrollo en el Proyecto de Render

Para consultar el estado del desarrollo del módulo de Render puedes mirar el Proyecto de Raytracing.

Otros programas de código abierto de renderizado (para su implementación futura):

Traducciones disponibles:

El entorno de Imágenes

El módulo Imagen gestiona distintos tipos de imágenes de bitmaps, y te permite abrirlos en FreeCAD. En la actualidad, el módulo permite abrir en una ventana de visualización aparte los formatos .bmp,.jpg,.png y xpm. También hay una herramienta que permite capturar una imagen de una webcam.


Traducciones disponibles:

El entorno de Croquizado

El entorno de Boceto permite dibujar rápidamente objetos 2D simples en el documento actual, y ofrecer diversas herramientas para poderlas modificar después. Algunas de dichas herramientas también funcionan sobre otros objetos de FreeCAD, no sólo en los creados con el entorno de Boceto. También proporciona un completo sistema de ajuste, y varias utilidades para manejar objetos y configuraciones.


Dibujando objetos

Estas son las herramientas para crear objetos.

  • Image:Draft_Line.png Línea de 2 puntos: Dibuja un segmento de línea entre 2 puntos
  • Image:Draft_Wire.png Polilínea (Línea de múltiples puntos): Dibuja una polilínea compuesta por múltiples segmentos de línea
  • Image:Draft_Circle.png Circunferencia: Dibuja una circunferencia a partir de su centro y radio
  • Image:Draft_Arc.png Arco: Dibuja un segmento de arco a partir de su centro, radio ángulo de inicio y ángulo final
  • Image:Draft_Rectangle.png Rectángulo: Dibuja un rectángulo a partir de 2 puntos de su diagonal
  • Image:Draft_Polygon.png Polígono: Dibuja un polígono regular a partir del centro y radio de la circunferencia que lo circunscribe
  • Image:Draft_BSpline.png BSpline: Dibuja una B-Spline a partir de una serie de puntos
  • Image:Draft_Text.png Texto: Dibuja una anotación de múltiples líneas de texto
  • Image:Draft_Dimension.png Cota: Dibuja una cota dimensional
  • Punto: Inserta un objeto punto

Modificando objetos

Estas son las herramientas para la edición de los objetos existentes. Trabajan sobre los objetos seleccionados, pero si no hay ningún objeto seleccionado, permiten seleccionar uno.

  • Image:Draft_Move.png Desplazar: Desplaza objeto(s) desde una ubicación a otra
  • Image:Draft_Rotate.png Girar: Gira objeto(s) desde un ángulo de inicio a un ángulo final
  • Image:Draft_Offset.png Equidistancia: Mueve segmentos de un objeto a cierta distancia
  • Image:Draft_Upgrade.png Promocionar: Une objetos en un objeto de nivel superior
  • Image:Draft_Downgrade.png Degradar: Descompone objetos en objetos de nivel inferior
  • Image:Draft_Trimex.png Recortar/Extender: Recorta o extiende un objeto
  • Image:Draft_Scale.png Escalar: Escala los objetos seleccionados alrededor de un punto base
  • Image:Draft_Edit.png Editar: Edita un objeto seleccionado
  • Image:Draft_PutOnSheet.png Dibujar: Escribe los objetos seleccionados en una Hoja de dibujo
  • Image:Draft_Shape2DView.png Shape 2D View: Crea un objeto 2D que es la vista 2D proyectada de otro objeto 3D
  • Contorno a BSpline: Convierte un contorno a BSpline y viceversa
  • Añadir punto: Añade un punto a un contorno o una BSpline
  • Borrar punto: Borra un punto de un contorno o BSpline
  • Boceto a croquis: Convierte un objeto de Boceto a Croquis y viceversa
  • Matriz: Crea una matriz polar o rectangular a partir de los objetos seleccionados
  • Clonar: Clona los objetos seleccionados

Herramientas de utilidad

Herramientas adicionales disponibles desde el menú contextual del botón derecho del ratón, dependiendo de los objetos seleccionados.

Formato de archivos

El módulo de Boceto proporciona a FreeCAD importadores y exportadores para los siguientes formatos de archivo:

Características adicionales

  • Ajuste: Permite colocar los nuevos puntos en lugares especiales de los objetos existentes
  • Restricciones: Permite situar los puntos nuevos horizontal o verticalmente respecto a puntos previos
  • Trabajando con coordenadas manualmente: Permite introducir coordenadas manualmente, en lugar de indicarlas en la pantalla

Configuración de preferencias

  • El módulo de croquizado también tiene su pantalla de preferencias

Archivos de guión

El módulo de Boceto incorpora una API completa de modo que puedes utilizar sus funciones en archivos de guión y macros

Traducciones disponibles:

Archivos de guión y macros

Macros

Las macros son una forma cómoda de crear acciones complejas en FreeCAD. Simplemente graba las acciones a medida que las haces, a continuación, lo guardas con un nombre, y las podrás reproducir siempre que lo desees. Dado que las macros son en realidad una lista de comandos de Python, también puedes editar y crear archivos de guión (scrips) o secuencias de comandos muy complejos.

¿Cómo funciona?

Si habilitas la salida en consola (Menú Editar -> Preferencias -> Macro -> Mostrar comandos de archivos de guión en la consola de Python), verás que en FreeCAD, cada acción que hacemos, como presionar un botón, da como salida un comando Python. Esos comandos son lo que se pueden grabar en una macro. La principal herramienta para la grabación de las macros es la barra de herramientas de macros: Image: Macros_toolbar.jpg. En ella tienes 4 botones: Grabar, detener la grabación, editar y reproducir la macro actual.


Es muy sencillo de utilizar: Presiona el botón de grabación, se pedirá que le asignes un nombre a tu macro, a continuación, realizar algunas acciones. Cuando termines, haz clic en el botón Detener grabación, y tus acciones se guardarán. Ahora puedes acceder al letrero de diálogo de macro con el botón de edición:

Image:Macros.jpg

Allí puedes manejar tus macros, eliminar, editar o crear otras nuevas desde cero. Si editas una macro, esta se abrirá en una ventana del editor donde se pueden realizar cambios en su código.

Ejemplo

Pulsa el botón de grabar, dale un nombre, digamos "cilindro de 10x10, entonces, en el Entorno de Pieza, crea un cilindro con radio = 10 y altura = 10. A continuación, pulsa el botón "Detener la sesión de grabación de la macro". En el letrero de diálogo de edición macros, puedes ver el código Python que se ha registrado, y, si lo deseas, realizar modificaciones en él. Para ejecutar la macro, basta con pulsar el botón de ejecutar en la barra de herramientas mientras la macro se encuentra en el editor. Tu macro siempre se guarda en el disco, por lo que cualquier cambio que hagas, o cualquier macro nueva que crees, siempre estará disponible la próxima vez que inicies FreeCAD.


Personalización

Por supuesto que no es práctico cargar una macro en el editor con el fin de usarla. FreeCAD proporciona formas mucho mejores de iniciar la macro, como la asignación de un atajo de teclado, o poner una entrada en el menú. Una vez que la macro se crea, todo esto se puede hacer a través de menú -> Herramientas -> Personalizar:


Image:Macros config.jpg

Así puedes hacer que tu macro se convierta en una auténtica herramienta, al igual que cualquier herramienta estándar de FreeCAD. Esto, sumado a la potencia de Python en FreeCAD, permite añadir fácilmente tus propias herramientas a la interfaz. Sigue leyendo en la página del Centro de usuarios avanzados si quieres saber más sobre los archivos de guión en lenguaje Python ...


Creación de macros sin grabar

También puedes copiar/pegar directamente código python en una macro, sin grabar acciones de la interfaz gráfica de usuario. Basta con crear una nueva macro, editarla, y pegar el código. A continuación, puedes guardar la macro del mismo modo que se guarda un documento de FreeCAD. La próxima vez que se inicie FreeCAD, la macro aparecerá bajo el apartado "Macros instaladas" del menú Macro.

Repositorio de Macros

Visita la página Recetas de macros para recoger algunas macros útiles para añadir a tu instalación de FreeCAD.


Traducciones disponibles:

Introducción a Python

Este es un pequeño tutorial hecho para quien sea nuevo en Python. Python es un lenguaje de programación de código abierto y multiplataforma. Python tiene varias características que lo hacen muy diferente de otros lenguajes de programación comunes, y es muy accesible para usuarios nuevos como tu:

  • Se ha diseñado especialmente para ser fácil de leer por los seres humanos, por lo que es muy fácil de aprender y comprender.
  • Se interpreta, es decir, a diferencia de lenguajes compilados como C, tu programa no necesitan ser compilado antes de ser ejecutado. El código que escribas podrá ser ejecutado, línea por línea si así lo deseas. Esto hace que sea muy fácil de aprender y de encontrar errores en su código, ya que va despacio, paso a paso.
  • Puede ser integrado en otros programas para ser utilizado como lenguaje de archivos de guión. FreeCAD tiene un intérprete de Python integrado, por lo que se puede escribir código Python en FreeCAD, que manipulará partes de FreeCAD, por ejemplo para crear la geometría. Esto es extremadamente potente, porque en lugar de simplemente pulsar un botón "crear esfera", que un programador ha puesto allí para ti, tienes la libertad de crear fácilmente tu propia herramienta para crear exactamente la geometría que desees.
  • Es extensible, puedes conectar fácilmente nuevos módulos en tu instalación de Python y extender su funcionalidad. Por ejemplo, tiene módulos que permiten a Python leer y escribir imágenes jpg, comunicarse con Twitter, programar las tareas a realizar por el sistema operativo, etc.


Así que, ¡manos a la obra! Ten en cuenta que lo que viene ahora es una introducción muy simple, de ningún modo un completo tutorial. Pero espero que después, tengas la base suficiente para explorar más profundamente en las interioridades de FreeCAD.

El intérprete

Por lo general, cuando escribes programas de ordenador, abres un editor de texto o tu entorno de programación favorito (que en la mayoría de los casos constará de un editor de texto con varias herramientas a su alrededor), escribes tu programa, a continuación, lo compilas y lo ejecutarás. La mayoría de las veces habrás cometido errores al escribir, así que tu programa no funcionará, y recibirás un mensaje de error diciendo lo que salió mal. Entonces regresarás a tu editor de texto, corregirás los errores, ejecutarás de nuevo, y así sucesivamente hasta que el programa funcione bien.

Todo este proceso se puede hacer, en Python, de forma transparente dentro del intérprete de Python. El intérprete es una ventana de Python con un símbolo del sistema, donde puedes simplemente escribir código Python. Si instalas en su ordenador Python (descargarlo desde su website si estás en Windows o Mac, o instalar desde el repositorio de paquetes si estás en linux), tendrás un intérprete Python en el menú de inicio. Pero FreeCAD también tiene un intérprete de Python en su parte inferior:


Image:Screenshot_pythoninterpreter.jpg

El intérprete muestra la versión de Python, y luego el símbolo >>>, que es el símbolo del sistema, es decir, donde se introduce el código Python. Escribir código en el intérprete es simple: una línea es una instrucción. Al pulsar Intro, tu línea de código se ejecutará (después de ser compilado de modo instantáneo e invisible). Por ejemplo, trata de escribir esto: 

print "hola"

print es una palabra clave especial de Python que significa, obviamente, imprimir algo en la pantalla. Al pulsar Intro, la operación se ejecuta, y el mensaje "hola" se imprime. Si cometes un error, por ejemplo vamos a escribir: 

print hola


Python nos dirá que no sabe lo que es hola. El caracter " especifica que el contenido es una cadena, que es simplemente, en la jerga de programación, un pedazo de texto. Sin el signo ", el comando de impresión cree que hola no era un trozo de texto, sino una palabra clave especial de Python. Lo importante es, que inmediatamente se notifica que has cometido un error. Al pulsar la flecha hacia arriba (o, en el intérprete FreeCAD, CTRL + flecha hacia arriba), puedes volver a la última orden que has escrito y corregirlo.

el intérprete de Python también incorpora un sistema de ayuda. Prueba a escribir: 

help

o, por ejemplo, supongamos que no entendemos lo que salió mal con nuestro comando anterior: print hola. queremos obtener información específica sobre el comando "print": 


help("print")

Entonces obtendrás una descripción más larga y completa de todo lo que el comando print puede hacer.

Ahora dominamos por completo nuestro intérprete, y podemos empezar con cosas serias.


Variables

Por supuesto, imprimir "hola" no es muy interesante. Más interesante es la impresión de cosas que no conocía antes, o dejar que Python las busque para ti. Ahí es donde el concepto de variable entra en juego. Una variable es simplemente un valor que se almacenan bajo un nombre. Por ejemplo, escribe lo siguiente: 

a = "hola"
print a

Supongo que entiendes lo que ocurrió, "guardaste" la cadena "hola" con el nombre a. Ahora, a ya no es un nombre desconocido más! Podemos utilizarlo en cualquier lugar, por ejemplo, en el comando de impresión. Podemos usar cualquier nombre que desees, respetando unas simples normas , como no usar espacios ni puntuación. Por ejemplo, podríamos escribir: 

hola = "mi propia versión de hola"
print hola

¿Ves? ahora hola no es una palabra indefinida más. ¿Qué pasa si, por una mala suerte terrible, elegiste un nombre que ya existe en Python? Supongamos que queremos almacenar nuestra cadena con el nombre de "print": 

print = "hola"

Python es muy inteligente y nos dirá que esto no es posible. Tiene algunas palabras clave "reservadas" que no se pueden modificar. Pero nuestras propias variables pueden ser modificadas en cualquier momento, eso es exactamente por lo qué se llaman variables, los contenidos pueden variar. Por ejemplo: 

miVariable = "hola"
print miVariable
miVariable = "adios"
print miVariable

Hemos cambiado el valor de miVariable. También podemos copiar variables: 

var1 = "hola"
var2 = var1
print var2

Ten en cuenta que es interesante dar buenos nombres para las variables, ya que cuando vayas a escribir programas largos, después de un tiempo no te acordarás de para que era su variable llamada "a". Pero si la llamas, por ejemplo miMensajeBienvenida, cuando vuelvas a verlo recordarás fácilmente para que se utiliza.

Números

Por supuesto, debes saber que la programación es útil para tratar todo tipo de datos, y los números en especial, no sólo cadenas de texto. Una cosa es importante, Python debe saber con que tipo de datos está tratando. Vimos en nuestro ejemplo print hola, que el comando de impresión print reconoció nuestro cadena "hola". Eso se debe a que mediante el caracter ", le dijimos específicamente al comando de impresión print que lo que vendría después era una cadena de texto.

Siempre se puede comprobar que tipo de datos contiene una variable con la palabra clave especial de python: Type() 


myVar = "hola"
type(myVar)

Nos dirá el contenido de myVar es "str", o una cadena en la jerga de python. Tenemos también otros tipos de datos, como números enteros y números en coma flotante: 


firstNumber = 10
secondNumber = 20
print firstNumber + secondNumber
type(firstNumber)


Esto ya es mucho más interesante, ¿no? Ahora ya tenemos una potente calculadora! Mira bien cómo funciona, Python sabe que el 10 y 20 son números enteros. Así que se almacenan como "int", y Python puede hacer con ellos todo lo que puede hacer con números enteros. Mira los resultados de este:

primerNumero = "10" secondNumber = "20" print primerNumero + secondNumber

¿Ves? Estamos obligando a Python a considerar que nuestras dos variables no son números sino simples piezas de texto. Python puede unir dos fragmentos de texto en conjunto, pero no va a tratar de calcular el resultado de la suma. Pero estábamos hablando de números enteros. También hay números en coma flotante. La diferencia es que los números enteros no tienen parte decimal, mientras que los números en coma flotante pueden tener una parte decimal: 

var1 = 13
var2 = 15.65
print "var1 is of type ", type(var1)
print "var2 is of type ", type(var2)

Int and Float pueden mezclarse sin problemas: 

total = var1 + var2
print total
print type(total)


Por supuesto que 'total' tiene decimales, ¿verdad? Por eso Python automáticamente decidió que el resultado es un float. En varios casos como éste, python decide automáticamente qué tipo dar al resultado. En otros casos no es así. Por ejemplo: 


varA = "hola 123"
varB = 456
print varA + varB

Esto nos dará un error, varA es un string y varB es un int, y Python no sabe que hacer. Pero podemos obligar a Python a convertir entre tipos: 

varA = "hola"
varB = 123
print varA + str(varB)

Ahora los dos son strings, la operación se puede hacer! Fíjate que convertimos en "string" a varB en el momento de implimir, peo no cambiamos VarB. Si quisieramos cambiar varB permanentemente en un string, necesitariamos hacer así: 

varB = str(varB)

Tambien podemos usar int() y float() para convertir en int y float si queremos: 

varA = "123"
print int(varA)
print float(varA)

Nota sobre comandos en Python

Habrás visto que en esta sección hemos usado el comando print de varias formas. Hemos impreso variables, sumas, varias cosas separadas por comas e incluso el resultado de otro comando Python como es type(). Tambien habrás notado que estos dos comandos: 

type(varA)
print type(varA)

dan exactamente el mismo resultado. Eso es porque estamos en un interprete, y todo es automáticamente impreso en la pantalla. Cuando escribamos programas mayores que corran fuera del interprete, no imprimirán automaticaemnte todo en la pantalla, por eso tendremos que usar el comando print. Pero desde ahora y hasta entonces, dejaremos de usar print aqui (iremos más rápido), de modo que escribiremos simplemente: 

myVar = "hola amigos"
myVar

Tambien habrás visto que muchos de los comandos (o palabras clave) de Python que hemos conocido, tiene paréntesis que le indican sobre que tienen que operar: type(), int(), str(), etc. La única excepción es el comando print, que de hecho no es una excepcion. Tambien funciona normalmente así: print("hola"), pero, como suele ocurrir, los programadores de Python hicieron una versión simplificada.

Listas

Otro tipo de dato interesante son las listas. Las listas son, simplemente, listas de otros datos. Del mismo modo que definimos una cadena de texto, string, usando " ", definimos listas usando [ ]: 

myList = [1,2,3]
type(myList)
myOtherList = ["Bart", "Frank", "Bob"]
myMixedList = ["hello", 345, 34.567]

Verás que pueden contener cualquier tipo de datos. Las listas son muy útiles porque pueden agrupar datos. Despues puede hacer muchas cosas con ellos, por ejemplo contarlos: 

len(myOtherList)

u obtener un elemento de una lista: 

myName = myOtherList[0]
myFriendsName = myOtherList[1]

Como vés, mientras el comando len() devuelve el número total de elementos en una lista, sus posiciones en la lista empiezan en 0. El primer elemento en una lista está simepre en la posición 0. Así, en myOtherList, "Bob" estará en la posición 2. Se pueden hacer muchas cosas con listas, como se muestra en aquí, como es ordenar sus contenidos, añadir o quitar elementos.

Una cosa interesante y divertida para ti: Un string es, en realidad, una lista de caracteres! Intenta hacer esto: 

myvar = "hello"
len(myvar)
myvar[2]

Normalmente, todo lo que puedes hacer con listas, también puede hacerse con strings.

Además de strings, ints, floats y lists, hay más tipos de datos incorporados, como son diccionarios, o puedes incluso crear tus propios tipos con clases.

Indentación

Un uso típico de las listas es el de ojearlas y hacer algo con cada elemento. Por ejemplo, mira esto: 

alldaltons = ["Joe", "William", "Jack", "Averell"]
for dalton in alldaltons:
   print dalton + " Dalton"

Aquí iteramos (es jerga de programación!) en nuestra lista con el comando "for ... in ..." y hacemos algo con cada uno de los elementos. Observa la especial sintaxis: el comando for termina con : lo que indica que lo que siga será un bloque de uno o más comandos.

Inmediatamente después de que metas la línea de comando terminada en : el cursor donde se meten los comandos cambia a ... lo que indica que Python ha visto la línea terminada en : y que lo que siga será parte de ella.


Cómo sabe Python cuantas de las siguientes líneas deben ser ejecutadas dentro del bucle for ... in ...?. Para eso, Python usa la indentación o indentado. Eso es que las siguientes líneas no empiezan inmediatamente al inicio del renglón. Se escibirán empezando con uno o varios espacios en blanco, o tabuladores. Otros leguajes de programación usan otros medios, como poner el bloque entre paréntesis, etc.

Mientras empieces las siguientes líneas con la misma indentación, serán consideradas como parte del mismo bloque for...in. Si empiezas una línea con dos espacios y la siguiente con 4, habrá un error. Para terminar, escribe otra línea, pero sin sangría, o simplemente pulsa Intro para salir del bloque for...in.

El indentado es estupendo, porque si los haces grandes (por ejemplo usando tabulador en lugar de espacios, porque es más grande), cuando se escribe un gran programa tendrás una visión clara de lo que se ejecuta dentro de cada cosa.

Veremos que muchos comandos distintos de los bloques for-in también puede tener sangría de código.

Los comandos for-in se pueden utilizar para muchas cosas que hay que hacer más de una vez. Por ejemplo se puede combinar con el comando range(): 

serie = range(1,11)
total = 0
print "sum"
for number in serie:
   print number
   total = total + number
print "----"
print total

O cosas mas complejas como esto: 

alldaltons = ["Joe", "William", "Jack", "Averell"]
for n in range(4):
   print alldaltons[n], " is Dalton number ", n

El comando range() tambien tiene la extraña particularidad de que comienza con 0 (si no se especifica el número de inicio) y que su último número será uno menos del número final que le indique. Esto es, por supuesto, para que trabaje bien con otros comandos Python. Por ejemplo: 

alldaltons = ["Joe", "William", "Jack", "Averell"]
total = len(alldaltons)
for n in range(total):
   print alldaltons[n]

Otro interesante uso de los bloques indentados es con el comando if. If ejecuta el bloque de código solo si se cumple una determianda condición. Por ejemplo: 

alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Joe" in alldaltons:
   print "We found that Dalton!!!"


Por supuesto, esto siempre imprimirá la primera frase. Pero trata de sustituir la segunda línea por: 

if "Lucky" in alldaltons:

Entonces no se imprime nada. También podemos especificar una clausula else: 

alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Lucky" in alldaltons:
   print "We found that Dalton!!!"
else:
   print "Such Dalton doesn't exist!"

Funciones

Los comandos estandard de Python no son tantos. En la actual version de Python hay unos 30, y ya conocemos algunos de ellos. ¿Pero, imagina que pudieramos inventar nuestros propios comandos? Pues podemos, y es sumamente fácil. De hecho, la mayoría de los módulos adicionales que puedes cargar en su instalación hacen eso. Añaden comandos que puedes usar. Un comando de usuario en Python se llama función y se crean así: 

def printsqm(myValue):
   print str(myValue)+" square meters"

printsqm(45)

Muy simple: el comando def() define una nueva función. Le da un nombre, y dentro del paréntesis define argumentos que usará en su función. Los Argumentos son datos que le pasará a la función.

Por ejemplo, mira el comando len(). Si escribes solo len(), Python te dirá que falta un argumento. Es decir, desea len () de algo, ¿no? Entonces, por ejemplo, si escribes len (myList) obtendrás la longitud de myList. myList es un argumento que se pasa a la función len (). la función len () está definida de tal manera que sepa qué hacer con lo que se le pasa. Lo mismo que hicimos aquí.

El nombre "myValue" puede ser cualquier cosa, y sólo será utilizado dentro de la función. Es sólo un nombre que se le asigna al argumento para que puedas hacer algo con él, pero también sirve para que la función sepa cuantos argumentos debe esperar. Por ejemplo, si haces esto: 

printsqm(45,34)


Habrá un error. Nuestra función fue programada para recibir un solo argumento, pero recibió dos, 45 y 34. En su lugar, podríamos hacer algo como esto: 

def sum(val1,val2):
   total = val1 + val2
   return total

sum(45,34)
myTotal = sum(45,34)

Hicimos una función que recibe dos argumentos, los suma, y devuelve ese valor. Devolver algo es muy útil, porque podemos hacer algo con el resultado, como almacenarlo en la variable myTotal. Por supuesto, ya que estamos en el intérprete y todo lo que hacemos se imprime, haciendo: 

sum(45,34)

se imprimirá el resultado en la pantalla, pero fuera del intérprete nada aparece en la pantalla (ya que no hay comando de impresión dentro de la función). Tendrías que hacer: 

print sum(45,34)

para que se imprima algo. Lee más sobre funciones aquí.

Módulos

Ahora que tenemos una buena idea de cómo funciona Python, necesitamos una última cosa: Cómo trabajar con archivos y módulos.

Hasta ahora, hemos escrito las instrucciones Python línea por línea en el intérprete. ¿Y si pudiéramos escribir varias líneas juntas, y ejecutarlas a la vez? Sin duda, sería más práctico para hacer cosas más complejas. Y también así podríamos salvar nuestro trabajo. Bueno, eso también es extremadamente fácil. Basta con abrir un editor de textos (como el Bloc de notas de Windows), y escribir tus líneas de Python, de la misma manera como las escribes en el intérprete, con indentación, etc. A continuación, guarda el archivo en alguna parte, preferentemente con una extensión .Py. Eso es todo, ya tienes un programa Python completo. Por supuesto, hay editores mucho mejores que el bloc de notas, pero esto es sólo para mostrar que un programa de Python no es más que un archivo de texto.

Para hacer a Python ejecutar ese programa, hay cientos de maneras. En Windows, simplemente haz clic derecho en el archivo, abrirlo con Python, y ejecutarlo. Pero también se puede ejecutar desde el intérprete de Python en sí. Para ello, el intérprete debe saber dónde está tu programa .Py. En FreeCAD, la forma más fácil es colocar su programa en un lugar que el intérprete de Python de FreeCAD sabe por defecto, como la carpeta bin de FreeCAD, o cualquiera de las carpetas Mod. Supongamos que escribes un archivo así: 


def sum(a,b):
   return a + b

print "test.py succesfully loaded"

y lo guardas como test.py en el directorio /bin de FreeCAD. Ahora, vamos a iniciar FreeCAD, y en la ventana del intérprete, escribe: 

import test

sin la extensión. py. Esto simplemente ejecuta el contenido del archivo, línea por línea, como si se hubiera escrito en el intérprete. La función suma se creará, y el mensaje se imprimirá. Pero hay una gran diferencia: el comando de importación sirve no sólo para ejecutar programas escritos en los archivos, como el nuestro, sino también para cargar las funciones que tienen en el interior, de modo que estén disponibles para el intérprete. Los archivos que contienen funciones, como la nuestra, se llaman módulos.

Normalmente cuando escribimos una función sum() en el intérprete, simplemente se ejecuta, así: 

sum(14,45)

como hicimos antes. Al importar un módulo que contiene nuestra función sum(), la sintaxis es un poco diferente. Hacemos: 

test.sum(14,45)


Es decir, el módulo se importa como un "contenedor", y todas sus funciones se encuentran dentro. Esto es muy útil, ya que puedes importar una gran cantidad de módulos, y mantener todo bien organizado. Así que, básicamente, Allá donde veas algo.algoMas, con un punto intermedio, lo que significa es que algoMas está dentro de algo.

También podemos sacar la parte test, e importar nuestra función sum() directamente en el espacio principal del intérprete, así: 

from test import *
sum(12,54)

Básicamente todos los módulos se comportan así. Importa un módulo, y ya puedes utilizar sus funciones así: module.function(argumento). Casi todos los módulos hacen eso: definen funciones, nuevos tipos de datos y clases que se pueden usar en el intérprete o en sus propios módulos de Python, porque nada impide que importes módulos dentro de tu módulo!

Una última cosa muy útil. ¿Cómo sabemos los módulos que tenemos, qué funciones se encuentran dentro y cómo utilizarlos (es decir, qué tipo de argumentos necesitan)? Vimos ya que Python tiene una función ayuda(). Si haces: 

help()
modules

Nos dará una lista de todos los módulos disponibles. Podemos ahora escribir q (de quit) para salir de la ayuda interactiva, e importar cualquiera de ellos. Incluso puedes navegar por su contenido con el comando dir() 

import math
dir(math)

Vamos a ver todas las funciones contenidas en el módulo de matemáticas, así como material extraño llamado __doc__, __file__, __name__. The __doc__ es extremadamente útil, es un texto de documentación. Cada función de un módulo (bien hecho) tiene un __doc__ que explica cómo usarlo. Por ejemplo, vemos que existe una función seno en el módulo de matemáticas. ¿Quieres saber cómo usarlo? 

print math.sin.__doc__

Y por último una pequeña golosina más: Cuando trabajamos en la programación de un módulo, frecuentemente querremos probarlo. De modo que una vez que escribimos una pequeña parte del módulo, en un interprete de Python, hacemos algo parecido a esto, para probar nuestro nuevo código: 

import myModule
myModule.myTestFunction()

Pero que pasa si vemos que myTestFunction() no funciona correctamente? Volvemos a nuestro editor y lo modificamos. Luego, en lugar de cerrar y volver a abrir el interprete de Python, podemos simplemente actualizar el módulo así: 

reload(myModule)

Empezando con FreeCAD

Bien, creo que debes tener una buena idea de cómo funciona Python, y puedes empezar a explorar lo que FreeCAD puede ofrecer. Las funciones Python de FreeCAD están todas bien organizadas en diferentes módulos. Algunos de ellos están ya cargados (importados) cuando inicias FreeCAD. Así, que simplemente haz 


dir()

y sigue leyendo en Archivos de guión básicos en FreeCAD...

Por supuesto, aquí sólo hemos visto una pequeña parte del mundo de Python. Hay muchos conceptos relevantes que no hemos mencionado. En la red hay dos documentos muy importantes como referencia sobre Python:

Asegúrate de tener a mano estos enlaces!

Traducciones disponibles:

Archivos de guión de Python en FreeCAD

FreeCAD está construido desde cero para que sea totalmente controlado por archivos de guión (scripts) de Python. Casi todas las partes de FreeCAD como la interfaz, el contenido de la escena, e incluso la representación de ese contenido en las vistas 3D, son accesibles desde el intérprete de Python incorporado, o desde sus propios archivos de guión. Como resultado, FreeCAD es, probablemente, una de las aplicaciones de diseño para ingeniería más personalizables de las disponibles en la actualidad.

En su estado actual, sin embargo, FreeCAD tiene muy pocos comandos "nativos" para interactuar con los objetos 3D. Sobre todo porque se encuentra todavía en una fase temprana de desarrollo, pero también porque la filosofía que hay detrás es más la de proporcionar una plataforma para el desarrollo CAD que una aplicación para un uso específico. Pero la facilidad de usar archivos de guión de Python dentro de FreeCAD probablemente ayudará a que pronto veamos funcionalidades nuevas que desarrollen los "usuarios avanzados", o, como de costumbre, los usuarios que conocen un poco de programación en Python. Python es uno de los lenguajes interpretados más populares, y debido a que es generalmente considerado como sencillo de aprender, tu también puedes estar proto creando tus propias macros de "usuario avanzado" sobre FreeCAD.

Si no estás familiarizado con Python, te recomendamos buscar tutoriales en Internet, y echar un rápido vistazo a su estructura. Python es un lenguaje muy fácil de aprender, sobre todo porque se puede ejecutar dentro de un intérprete, donde tanto comandos simples como programas completos pueden ejecutarse sobre la marcha, sin necesidad de compilar nada. FreeCAD ha incorporado un intérprete de Python. Si no ves la ventana denominada 'Consola de Python' como se muestra más abajo, puedes activarla en el menú Vista -> Vistas -> Consola de Python para mostrar el interprete.

El intérprete

Desde el intérprete puedes acceder a todos los módulos de Python instalados en el sistema, así como a los módulos de FreeCAD incorporados, y a todos los módulos adicionales de FreeCAD que puedas instalar más tarde. La imagen siguiente muestra el intérprete de Python:

The FreeCAD python interpreter

También, puedes ejecutar código Python y navegar a través de las clases y funciones disponibles. FreeCAD proporciona un navegador de clases muy útil para la exploración de su nuevo mundo FreeCAD. Cuando se escribe el nombre de una clase conocida seguido de un punto (.) (significando que quieres añadir algo de esa clase), se abre una ventana del navegador de clases, donde se puede navegar entre las subclases y métodos disponibles. Cuando se selecciona algo, se mostrará un texto de ayuda asociado (si existe):

The FreeCAD class browser

Así que, comienza por esto escribiendo App. o Gui. y verás qué pasa. Otra forma más genérica de exploración del contenido de los módulos y las clases de Python es usar el comando print dir(). Por ejemplo, escribiendo print dir() listará todos los módulos cargados en FreeCAD. print Dir(App) te mostrará todo el interior del módulo App, etc.

Otra característica útil del intérprete es la posibilidad de volver atrás en el historial de comandos y recuperar una línea de código que ya has escrito antes. Para navegar en el historial de comandos, sólo tienes que utilizar CTRL + flecha arriba o CTRL + flecha abajo.

Al hacer clic derecho en la ventana del intérprete también tienes otras opciones, tales como copiar todo el historial (útil para experimentar con algo, y luego hacer un archivo de guión con todo ello), o insertar el nombre de un archivo con su ruta completa.

Ayuda de Python

En el menú Ayuda de FreeCAD, encontrarás una entrada llamada "Módulos de Python", que abrirá una ventana que contiene una documentación completa, generada en tiempo real, de todos los módulos de Python a disposición del intérprete de FreeCAD, incluyendo Python y los módulos propios de FreeCAD, los módulos instalados por el sistema, y los módulos de FreeCAD adicionales. La documentación disponible depende del esfuerzo que cada desarrollador de los módulos puso en documentar su código pero, en general, los módulos de Python tienen la reputación de estar bastante bien documentados. Tu ventana de FreeCAD debe permanecer abierta para que este sistema de documentación funcione.

Módulos incorporados (Built-in)

Como FreeCAD está diseñado para poder ser ejecutado sin interfaz gráfica de usuario, casi toda su funcionalidad se separa en dos grupos: las funciones principales, llamado App, y la funcionalidad de la interfaz gráfica de usuario, llamado Gui. Así, nuestros dos principales módulos incorporados en FreeCAD se llaman App y Gui. Estos dos módulos también son accesibles desde fuera de los archivos de guiones de comandos del intérprete, con los nombres respectivos de FreeCAD y FreeCADGui.


  • En el módulo App, encontrarás todo lo relacionado con la aplicación en sí, como los métodos para abrir o cerrar archivos, y lo relacionado con los documentos, como los ajustes del documento activo o listar su contenido.
  • En el módulo Gui, encontrarás herramientas para la gestión de la interfaz gráfica de usuario y el acceso a sus elementos, como los entornos (workbench) y sus barras de herramientas y, más interesante, la representación gráfica de todo el contenido de FreeCAD.

Listar los contenidos de todos esos módulos es una tarea poco "productiva" ya que crecen muy rápido a lo largo del desarrollo de FreeCAD. Pero las dos herramientas de navegación (el navegador de clases y la ayuda de Python) te debería dar, en cualquier momento, una documentación actualizada y completa de estos módulos.

Los objetos App y los objetos GUI

Como hemos dicho, en FreeCAD, todo esta repartido entre el núcleo y la representación. Esto incluye también los objetos en 3D. Puedes acceder a la definición de propiedades de los objetos (llamadas características de FreeCAD) a través del módulo de la aplicación, y cambiar la forma en que están representados en la pantalla a través del módulo GUI. Por ejemplo, un cubo tiene propiedades que lo definen, como anchura, longitud, altura, que se almacenan en un objeto App, y las propiedades de la representación, como el color de las caras, modo de dibujo, que se almacenan en su correspondiente objeto GUI.

Esta forma de hacer las cosas permite una amplia gama de usos, como los algoritmos que sólo funcionan en la parte definitoria de características, sin la necesidad de ocuparse de ningun aspecto visual, o incluso redirigir el contenido del documento con la aplicación no-gráfica, como listas, hojas de cálculo o análisis de elementos.

Por cada objeto App de tu documento, existe su correspondiente objeto GUI. El documento en sí mismo, en realidad, también tiene objetos App y GUI. Esto, por supuesto, sólo es válido cuando se ejecuta FreeCAD con su interfaz completo. En la versión de línea de comandos, no existe interfaz gráfica de usuario, por lo que sólo habrá objetos App. Ten en cuenta que la parte de interfaz gráfica de usuario de los objetos se genera nuevamente cada vez que un objeto App se marca como "que se vuelven a calcular" (por ejemplo, cuando uno de sus parámetros ha cambiado), por lo que los cambios que podría haber hecho al objeto Gui directamente podrían perderse.



para acceder a la parte App de algo, escribe: 

myObject = App.ActiveDocument.getObject("ObjectName")

donde "ObjectName" es el nombre de tu objeto. Tambien puedes poner: 

myObject = App.ActiveDocument.ObjectName

para acceder la la parte GUI del mismo objeto, escribe: 

myViewObject = Gui.ActiveDocument.getObject("ObjectName")

donde "ObjectName" es el nombre de tu objeto. También puedes escribir: 

myViewObject = App.ActiveDocument.ObjectName.ViewObject

Si no tenemos GUI (por ejemplo en el modo de línea de comandos), la última línea no devolverá nada.


Los objetos de documento

En FreeCAD todo tu trabajo reside en el interior de los documentos. Un documento contiene la geometría y se pueden guardar en un archivo. Varios documentos se pueden abrir al mismo tiempo. El documento, al igual que la geometría contenidos en el interior, tiene objetos App y Gui. El objeto App contiene las definiciones de geometría real, mientras que el objeto Gui contiene los puntos de vista diferentes de tu documento. Puedes abrir varias ventanas, cada una mostrando tu trabajo con un factor de zoom diferente o un determinado punto de vista. Estas vistas forman parte del objeto Gui de tu documento.

Para acceder a la parte App del documento abierto actualmente (activo), teclea: 

myDocument = App.ActiveDocument

Para crear un nuevo documento, teclea: 

myDocument = App.newDocument("Document Name")

Para acceder a la parte GUI del documento abierto actualmente (active), teclea: 

myGuiDocument = Gui.ActiveDocument

Para acceder a la vista actual, teclea: 

myView = Gui.ActiveDocument.ActiveView

Utilizando módulos adicionales

Los módulos FreeCAD y FreeCADGui son exclusivamente responsables de la creación y mantenimiento de objetos en el documento de FreeCAD. Normalmente no hacen nada como crear o modificar geometría. Eso es porque esa geometría puede ser de diversos tipos, y así es manejada por módulos adicionales, cada uno responsable de manejar ciertos tipos de geometría. Por ejemplo, el Módulo de pieza utiliza el kernel de OpenCascade, y por tanto es capaz de crear y manipular geometría de tipo B-rep, la cual es para la que se ha construido OpenCascade. El Módulo de malla es capaz de construir y modificar objetos de malla. De ese modo, FreeCAD es capaz de manejar un amplio rango de tipos de objetos, que pueden coexistir todos en el mismo documento, y nuevos tipos se podrían añadir fácilmente en el futuro.

Creación de objetos

Cada módulo tiene su propio modo de tratar sus geometrías, pero algo que todos ellos normalmente pueden hacer es crear objetos en el documento. Pero el documento de FreeCAD es consciente de los tipos de objetos disponibles proporcionados por los módulos: 

FreeCAD.ActiveDocument.supportedTypes()

listará todos los objetos que puedes crear. Por ejemplo, vamos a crear una malla (tratada por el módulo de malla) y una pieza (tratada por el módulo de pieza): 

myMesh = FreeCAD.ActiveDocument.addObject("Mesh::Feature","myMeshName")
myPart = FreeCAD.ActiveDocument.addObject("Part::Feature","myPartName")

El primer argumento es el tipo de objeto, el segundo el nombre del objeto. Nuestros dos objetos parecen casi lo mismo: Aún no contienen geometría, y la mayoría de sus propiedades son iguales cuando los inspeccionas con dir(myMesh) y dir(myPart). Excepto por una cosa, myMesh tiene una propiedad "Mesh" y "Part" tiene una propiedad "Shape". Eso es donde la malla y la pieza son almacenadas. Por ejemplo, vamos a crear una pieza de cubo y almacenarla en nuestro objeto myPart: 

import Part
cube = Part.makeBox(2,2,2)
myPart.Shape = cube

Podrías probar almacenando el cubo dentro de la propiedad Mesh del objeto myMesh, devolverá un error quejándose de un tipo erróneo. Eso es porque dichas propiedades están creadas para almacenar sólo un cierto tipo. En la propiedad Mesh de myMesh, sólo puedes almacenar algo creado con el módulo de malla. Observa que la mayoría de módulos también tienen un atajo para añadir su geometría al documento: 

import Part
cube = Part.makeBox(2,2,2)
Part.show(cube)

Modificando objetos

La modificación de un objeto se hace del mismo modo: 

import Part
cube = Part.makeBox(2,2,2)
myPart.Shape = cube

Ahora vamos a cambiar la forma por una mayor: 

biggercube = Part.makeBox(5,5,5)
myPart.Shape = biggercube

Preguntando a los objetos

Siempre puedes mirar el tipo de un objeto así: 

myObj = FreeCAD.ActiveDocument.getObject("myObjectName")
print myObj.Type

o saber si un objeto es derivado de uno de los básicos (característica de Pieza, característica de malla, etc): 

 print myObj.isDerivedFrom("Part::Feature")

Ahora puedes empezar a jugar con FreeCAD de verdad! Para ver lo que puedes hacer con el Módulo de pieza, lee la página Archivos de guión de Piezas, o la página Archivos de guión de mallas para trabajar con el Módulo de malla. Observa que, aunque los módulos de Pieza y Malla son los más completos y ampliamente utilizados, otros módulos como el Módulo de Boceto también tienen archivos de guión APIs que pueden ser útiles para ti. Para ver una lista completa de cada módulo y sus herramientas disponibles, visita la sección Category:API/es.

Traducciones disponibles:

Introducción

En primer lugar tienes que importar el módulo Malla: 

import Mesh

Después de eso, ya tendrás acceso al módulo Malla y la clase Malla, que ofrecen las funciones del nucleo FreeCAD C++ Mesh-Kernel.


Creación y Carga

Para crear un objeto malla vacío sólo tienes que utilizar el constructor estándar: 

malla = Mesh.Mesh()

También puedes crear un objeto desde un archivo 

malla = Mesh.Mesh ('D: / temp / Something.stl')

(Una lista de formatos de archivo compatibles se puede encontrar bajo 'Mallas' aquí.)


O también puedes crear la malla a partir de un conjunto de triángulos descrito por sus vértices: 

planarMesh = [
# triangle 1
[-0.5000,-0.5000,0.0000],[0.5000,0.5000,0.0000],[-0.5000,0.5000,0.0000],
#triangle 2
[-0.5000,-0.5000,0.0000],[0.5000,-0.5000,0.0000],[0.5000,0.5000,0.0000],
]
planarMeshObject = Mesh.Mesh(planarMesh)


El núcleo de mallas, Mesh-Kernel, se encarga de crear una estructura topológica de datos correcta, ordenando conjuntamente los puntos coincidentes y los bordes. Más adelante podrás ver cómo examinar y revisar los datos de la malla.

Modelado

Para crear geometrías regulares puedes utilizar el script de Python BuildRegularGeoms.py. 

import BuildRegularGeoms

Esta secuencia de comandos proporciona métodos para definir cuerpos de revolución sencillos, como esferas, elipsoides, cilindros, toroides y conos. Y también tiene un método para crear un cubo simple. Para crear un toroide, por ejemplo, se puede hacer de la siguiente manera: 

t = BuildRegularGeoms.Toroid(8.0, 2.0, 50) # list with several thousands triangles
m = Mesh.Mesh(t)


Los dos primeros parámetros definen los radios del toroide y el tercer parámetro es un factor de submuestreo relacionado con el número de triángulos que se han de crear. Cuanto mayor sea este valor, más suave es la forma y mejor acabado tiene el cuerpo. 


m1, m2              # are the input mesh objects
m3 = Mesh.Mesh(m1)  # create a copy of m1
m3.unite(m2)        # union of m1 and m2, the result is stored in m3
m4 = Mesh.Mesh(m1)
m4.intersect(m2)    # intersection of m1 and m2
m5 = Mesh.Mesh(m1)
m5.difference(m2)   # the difference of m1 and m2
m6 = Mesh.Mesh(m2)
m6.difference(m1)   # the difference of m2 and m1, usually the result is different to m5


Por último, un ejemplo completo que calcula la intersección entre una esfera y un cilindro que corta a la esfera. 

import Mesh, BuildRegularGeoms
sphere = Mesh.Mesh( BuildRegularGeoms.Sphere(5.0, 50) )
cylinder = Mesh.Mesh( BuildRegularGeoms.Cylinder(2.0, 10.0, True, 1.0, 50) )
diff = sphere
diff.difference(cylinder)
d = FreeCAD.newDocument()
d.addObject("Mesh::Feature","Diff_Sphere_Cylinder").Mesh=diff
d.recompute()


Examen y pruebas

Escribe tus propios algoritmos

Exportación

Puedes incluso escribir la malla en un módulo de Python: 

m.write("D:/Develop/Projekte/FreeCAD/FreeCAD_0.7/Mod/Mesh/SavedMesh.py")
import SavedMesh
m2 = Mesh.Mesh(SavedMesh.faces)

Interfaces gráficas de usuario relacionadas

Ajustes y pruebas

Una extensa, aunque dificil de usar, librería de archivos de guión relacionados con mallas son los scripts de prueba del módulo Malla. En esta unidad, literalmente todos los métodos son invocados, y se ajustan todas las propiedades y atributos. Así que si eres lo suficientemente audaz, echa un vistazo al Módulo de prueba de unidades.



Traducciones disponibles:

Esta página describe diversos métodos para crear y modificar formas de piezas desde Python. Antes de leer esta página, si eres nuevo en Python, es una buena idea leer la Introducción a Python y como funcionan los archivos de guión en FreeCAD.

Introducción

Aquí le explicamos cómo controlar el Módulo de Pieza directamente desde el intérprete de Python de FreeCAD, o desde cualquier archivo de guión externo. Asegúrate de navegar por la sección Archivos de guión y las páginas Conceptos básicos de archivos de guión en FreeCAD si necesitas más información acerca de cómo funcionan los archivos de guión de Python en FreeCAD.

Diagrama de clases

Ésta es una descripción Lenguaje Unificado de Modelado (UML) de las clases más importante del módulo de Pieza:

Python classes of the Part module

Geometría

Los objetos geométricos son la piedra angular de todos los objetos topológicos:

  • geom clase base de los objetos geométricos
  • line Una línea recta en 3D, definido por el punto de inicio y el punto final
  • circle Círculo o segmento de círculo definido por un punto centro y los puntos de inicio y final
  • ...... Y en breve más cosas ;-)

Topología

Los siguientes tipos de datos topológicos están disponibles:

  • compound Un grupo de cualquier tipo de objetos topológicos.
  • compsolid Un sólido compuesto es un grupo de sólidos concetados por sus caras. Es una extensión de las nociones de WIRE y SHELL en el ámbito de los sólido.
  • solid Una región del espacio limitada por shells. Es tridimensional.
  • shell Un conjunto de caras conectadas por sus bordes. Una shell puede ser abierta o cerrada.
  • face En 2D es parte de un plano; en 3D es parte de una superficie. Su geometría está limitada por sus contornos. Es un ente bidimensional.
  • wire Un grupo de bordes conectados por sus vértices. Puede tener un contorno abierto o cerrado, dependiendo que que sus bordes estén o no conectados.
  • edge Un elemento topológico que corresponde a una curva limitada. Un borde está normalmente limitado por vértices. Es un ente unidimensional.
  • vertex Un elemento topológico que se corresponde con un punto. Tiene dimensión cero.
  • shape Un concepto genérico que abarca todos los anteriores.

Ejemplo rápido: Creación de topologías básicas

Wire

Crearemos ahora una topología por construcción de geometría simple. Como un caso de estudio utilizaremos una pieza como se puede ver en la imagen que consiste en cuatro vértices, dos circunferencias y dos líneas.

Creación de geometría

Primero tenemos que crear las distintas partes de la geometría de este contorno. Y tenemos que tener cuidado de que los vértices de las partes de la geometría están en la misma posición. De otro modo después podríamos no ser capaces de conectar las partes de la geometría en una topología!

Así que primero creamos los puntos: 

from FreeCAD import Base
V1 = Base.Vector(0,10,0)
V2 = Base.Vector(30,10,0)
V3 = Base.Vector(30,-10,0)
V4 = Base.Vector(0,-10,0)

Arco

Circle

Para crear un arco de circunferencia crearemos puntos de ayuda y crearemos el arco a través de tres puntos: 

VC1 = Base.Vector(-10,0,0)
C1 = Part.Arc(V1,VC1,V4)
# and the second one
VC2 = Base.Vector(40,0,0)
C2 = Part.Arc(V2,VC2,V3)

Línea

Line

La línea puede crearse de forma muy simple a partir de los puntos: 

L1 = Part.Line(V1,V2)
# and the second one
L2 = Part.Line(V4,V3)

Poniendo todo junto

El último paso es poner los elementos base de la geometría juntos y formar una forma topológica: 

S1 = Part.Shape([C1,C2,L1,L2])

Crear un prisma

Ahora extruir el contorno en una dirección y crear una forma 3D real: 

W = Part.Wire(S1.Edges)
P = W.extrude(Base.Vector(0,0,10))

Mostrar todo 

Part.show(P)

Creación de formas básicas

Puedes crear fácilmente objetos topológicos simples con los métodos "make...()" del Módulo Parte: 

b = Part.makeBox(100,100,100)
Part.show(b)

Otros métodos make...() disponibles:

  • makeBox(l,w,h) -- construye una caja ubicada en p y apuntando en la dirección d con las dimensiones (l, w, h).
  • makeCircle(radius) -- Hace un círculo con un radio dado.
  • makeCone(radius1,radius2,height) -- Hace un cono con un radio y altura dados.
  • makeCylinder(radius,height) -- Hace un cilindro con un radio y altura dados.
  • makeLine((x1,y1,z1),(x2,y2,z2)) -- Hace una línea entre 2 puntos
  • makePlane(length,width) -- Hace un plano con longitud y anchura dados.
  • makePolygon(list) -- Hace un polígono con una lista de puntos
  • makeSphere(radius) -- Hace una esfera con un radio dado.
  • makeTorus(radius1,radius2) -- Hace un toro con sus radios dados.

Mira la página APIde piezas para una lista completa de los métodos disponibles del módulo de pieza.

Importing the needed modules

Primero tenemos que importar el módulo de piezas así podremos utilizar su contenido en Python. También importamos el módulo base desde dentro del módulo de FreeCAD: 

import Part
from FreeCAD import Base

Creación de un Vector

Los Vectores son una de las piezas de información más importantes cuando se construyen formas. Contienen 3 números normalmente (pero no necesariamente siempre) las coordenadas cartesianas X, Y y Z. Puedes crear un vector así: 

myVector = Base.Vector(3,2,0)

Simplemente creamos un vector en las coordenadas X=3, Y=2, Z=0. En el módulo de pieza, los vectores se utilizan en todas partes. Las formas de las piezas también utilizan otro tipo de representaciones de punto, llamada Vértice, el cual en realidad no es más que un contenedor para un vector. Puedes acceder al vector de un vértice así: 

myVertex = myShape.Vertexes[0]
print myVertex.Point
> Vector (3, 2, 0)

Creación de una arista

Un borde no es otra cosa mas que una linea entre dos vértices: 

edge = Part.makeLine((0,0,0), (10,0,0))
edge.Vertexes
>[<Vertex object at 01877430>, <Vertex object at 014888E0>]

Nota: También puedes crear una arista pasándole dos vértices. 

vec1 = Base.Vector(0,0,0)
vec2 = Base.Vector(10,0,0)
line = Part.Line(vec1,vec2)
edge = line.toShape()

Se puede determinar la longitud y el centro de un borde así: 

edge.Length
>10.0
edge.CenterOfMass
>Vector (5, 0, 0)

Poniendo la forma en la pantalla

Hemos creado un objeto arista, pero no aparece en ninguna parte de la pantalla. Esto es porque simplemente manejamos objetos de Python aquí. La escena 3D de FreeCAD sólo muestra lo que le digas que se muestre. Para hacerlo, utilizamos este simple método: 

Part.show(edge)

Un objeto se creará en nuestro documento de FreeCAD, y nuestra forma "edge" será atribuido a él. Utiliza esto si es momento para mostrar tu creación en la pantalla.

Creación de un contorno

Un contorno es una línea de múltiples aristas y se puede crear a partir de una lista de aristas, o incluso de una lista de contornos: 

edge1 = Part.makeLine((0,0,0), (10,0,0))
edge2 = Part.makeLine((10,0,0), (10,10,0))
wire1 = Part.Wire([edge1,edge2]) 
edge3 = Part.makeLine((10,10,0), (0,10,0))
edge4 = Part.makeLine((0,10,0), (0,0,0))
wire2 = Part.Wire([edge3,edge4])
wire3 = Part.Wire([wire1,wire2])
wire3.Edges
> [<Edge object at 016695F8>, <Edge object at 0197AED8>, <Edge object at 01828B20>, <Edge object at 0190A788>]
Part.show(wire3)

Part.show(wire3) mostrará las 4 aristas que componen nuestro contorno. Otra información útil se puede recuperar fácilmente: 

wire3.Length
> 40.0
wire3.CenterOfMass
> Vector (5, 5, 0)
wire3.isClosed()
> True
wire2.isClosed()
> False

Creación de una cara

Sólo serán válidas las caras creadas a partir de contornos cerrados. En este ejemplo, wire3 es un contorno cerrado pero wire2 no es un contorno cerrado (mira más arriba) 

face = Part.Face(wire3)
face.Area
> 99.999999999999972
face.CenterOfMass
> Vector (5, 5, 0)
face.Length
> 40.0
face.isValid()
> True
sface = Part.Face(wire2)
face.isValid()
> False

Sólo las caras tendrán un área, ni los contornos ni las aristas.

Creación de una circunferencia

Una circunferencia se puede crear de forma tan simple como esta: 

circle = Part.makeCircle(10)
circle.Curve
> Circle (Radius : 10, Position : (0, 0, 0), Direction : (0, 0, 1))

Si deseas crearlo en cierta posición y con cierta dirección: 

ccircle = Part.makeCircle(10, Base.Vector(10,0,0), Base.Vector(1,0,0))
ccircle.Curve
> Circle (Radius : 10, Position : (10, 0, 0), Direction : (1, 0, 0))

ccircle se creará a una distancia de 10 en el eje x desde el origen, y estará orientado hacia el eje x. Nota: makeCircle sólo acepta Base.Vector() para posición y normal, pero no admite tuplas. Tambien puedes crear una parte de una circunferencia dando su ángulo de inicio y fin, así: 

from math import pi
arc1 = Part.makeCircle(10, Base.Vector(0,0,0), Base.Vector(0,0,1), 0, 180)
arc2 = Part.makeCircle(10, Base.Vector(0,0,0), Base.Vector(0,0,1), 180, 360)

Juntando arc1 y arc2 obtendremos una circunferencia. Los ángulos deberán indicarse en grados, si los tienes en radianes simplemente conviertelos según la fórmula: degrees = radians * 180/PI o usando el módulo Python de matemáticas (después de importarlo, obviamente): 

degrees = math.degrees(radians)

Creación de un arco por varios puntos

Desafortunadamente no hay ninguna función makeArc pero tenemos la función Part.Arc para crear un arco a lo largo de tres puntos. Básicamente se puede suponer como un arco de unión entre el punto de partida y el punto final, pasando por el punto medio. Part.Arc crea un objeto arco en el que .toShape() tiene que ser llamado para obtener el objeto arista, del mismo modo como utilizamos Part.Line en lugar de Part.makeLine. 

arc = Part.Arc(Base.Vector(0,0,0),Base.Vector(0,5,0),Base.Vector(5,5,0))
arc
> <Arc object>
arc_edge = arc.toShape()

Arc solo acepta puntos como Base.Vector() no acepta tuplas. arc_edge es lo que queremos que podemos mostrar utilizando Part.show(arc_edge). También puedes obtener un arco utilizando una porción de una circunferencia:

arc_edge es lo que queríamos conseguir, y podemos visualizar utilizando Part.show (arc_edge). Si desea una pequeña parte de un círculo como un arco, también es posible: 

from math import pi
circle = Part.Circle(Base.Vector(0,0,0),Base.Vector(0,0,1),10)
arc = Part.Arc(c,0,pi)

Los arcos son aristas válidas, como las líneas. Así que también pueden utilizarse en los contornos.

Creación de un polígono

Un polígono es simplemente un contorno con múltiples aristas rectas. La función makePolygon toma una lista de puntos y crea un contorno a través de dichos puntos: 

lshape_wire = Part.makePolygon([Base.Vector(0,5,0),Base.Vector(0,0,0),Base.Vector(5,0,0)])

Creación de un plano

Un plano es simplemente una superficie rectangular plana. El método utilizado para crear uno es este: makePlane(length,width,[start_pnt,dir_normal]). Por defecto start_pnt = Vector(0,0,0) y dir_normal = Vector(0,0,1). Utilizando dir_normal = Vector(0,0,1) crearemos el plano orientado hacia el eje Z, mientras que con dir_normal = Vector(1,0,0) crearemos el plano orientado hacia el eje X: 

plane = Part.makePlane(2,2)
plane
><Face object at 028AF990>
plane = Part.makePlane(2,2, Base.Vector(3,0,0), Base.Vector(0,1,0))
plane.BoundBox
> BoundBox (3, 0, 0, 5, 0, 2)

BoundBox es un prisma encerrando el plano con una diagonal empezando en (3,0,0) y terminando en (5,0,2). Aquí el espesor de BoundBox en el eje Y es cero, ya que nuestra forma es totalmente plana.

Nota: makePlane sólo acepta Base.Vector() para start_pnt y dir_normal pero no tuplas

Creación de una elipse

Para crear una elipse existen varios métodos: 

Part.Ellipse()

Crea una elipse cuyo radio mayor es 2 y el radio menor 1 con centro en el (0,0,0) 

Part.Ellipse(Ellipse)

Crea una copia de la elipse dada 

Part.Ellipse(S1,S2,Center)

Crea una elipse centrada en el punto Center, donde el plano de la elipse está definido por Center, S1 y S2, su eje mayor está definido por Center y S1, su radio mayor es la distancia entre Center y S1, y su radio menor es la distancia entre S2 y el eje mayor. 

Part.Ellipse(Center,MajorRadius,MinorRadius)

Crea una elipse con radios mayor y menor MajorRadius y MinorRadius respectivamente, y ubicada en el plano definido por Center y la normal (0,0,1) 

eli = Part.Ellipse(Base.Vector(10,0,0),Base.Vector(0,5,0),Base.Vector(0,0,0))
Part.show(eli.toShape())

En el código de arriba hemos pasado S1, S2 y center. De forma similar a Arc, Ellipse también crea un objeto elipse pero no una arista, así que tenemos que convertirlo en una arista utilizando toShape() para mostrarlo.

Nota: Arc sólo acepta Base.Vector() para puntos pero no tuplas 

eli = Part.Ellipse(Base.Vector(0,0,0),10,5)
Part.show(eli.toShape())

para el constructor de la elipse de arriba hemos pasado el centro, MajorRadius y MinorRadius

Creación de un toro

Utilizando el método makeTorus(radius1,radius2,[pnt,dir,angle1,angle2,angle]). Por defecto pnt=Vector(0,0,0),dir=Vector(0,0,1),angle1=0,angle2=360 y angle=360. Considera un toro como un pequeño circulo barrido a lo largo de una circunferencia grande. Radius1 es el radio de la circunferencia grande, radius2 es el radio del círculo pequeño, pnt es el centro del toro y dir es la dirección normal. angle1 y angle2 son ángulos en radianes para el círculo pequeño, el último parámetro angle es para hacer una sección del toro: 

torus = Part.makeTorus(10, 2)

El código de arriba creará un toro con diámetro 20 (radio 10) y espesor 4 (radio del círculo pequeño 2) 

tor=Part.makeTorus(10,5,Base.Vector(0,0,0),Base.Vector(0,0,1),0,180)

El código de arriba creará una sección del toro 

tor=Part.makeTorus(10,5,Base.Vector(0,0,0),Base.Vector(0,0,1),0,360,180)

El código de arriba creará un semi toro, sólo el último parámetro se ha cambiado, dando el valor 180 creará el toro desde 0 hasta 180, eso es, medio toro.

Creación de un cubo o prisma

Utilizando makeBox(length,width,height,[pnt,dir]). Por defecto pnt=Vector(0,0,0) y dir=Vector(0,0,1) 

box = Part.makeBox(10,10,10)
len(box.Vertexes)
> 8

Creación de una esfera

Utilizando makeSphere(radius,[pnt, dir, angle1,angle2,angle3]). Por defecto pnt=Vector(0,0,0), dir=Vector(0,0,1), angle1=-90, angle2=90 y angle3=360. angle1 y angle2 son el punto vertical mínimo y máximo de la esfera, angle3 es el diámetro de la esfera. 

sphere = Part.makeSphere(10)
hemisphere = Part.makeSphere(10,Base.Vector(0,0,0),Base.Vector(0,0,1),-90,90,180)

Creación de un cilindro

Utilizando makeCylinder(radius,height,[pnt,dir,angle]). Por defecto pnt=Vector(0,0,0),dir=Vector(0,0,1) y angle=360 

cylinder = Part.makeCylinder(5,20)
partCylinder = Part.makeCylinder(5,20,Base.Vector(20,0,0),Base.Vector(0,0,1),180)

Creación de un cono

Utilizando makeCone(radius1,radius2,height,[pnt,dir,angle]). Por defecto pnt=Vector(0,0,0), dir=Vector(0,0,1) y angle=360 

cone = Part.makeCone(10,0,20)
semicone = Part.makeCone(10,0,20,Base.Vector(20,0,0),Base.Vector(0,0,1),180)

Modificando formas

Existen diversos métodos para modificar formas. Algunas son simples operaciones de transformación como mover o rotar formas, otras son más complejas, como la unión y diferencia de una forma y otra. are simple transformation operations such as moving or rotating shapes, other are more complex, such as unioning and subtracting one shape from another. Tenlo en cuenta

Operaciones de transformación

Traslación de una forma

Traslación es el acto de mover una forma de una situación a otra. Cualquier forma (aristas, caras, cubos, etc...) se puede trasladar del mismo modo: 

myShape = Part.makeBox(2,2,2)
myShape.translate(Base.Vector(2,0,0))

Esto moverá nuestra forma "myShape" 2 unidades en la dirección del eje X.

Rotación de una forma

Para rotar una forma, necesitas especificar el centro de rotación, el eje, y el ángulo de rotación: 

myShape.rotate(Vector(0,0,0),Vector(0,0,1),180)

El código de arriba rotará la forma 180 grados alrededor del eje Z.

Transformaciones genéricas con matrices

Una matriz es un modo muy conveniente de almacenar transformaciones en el mundo 3D. En una simple matriz, puedes establecer traslaciones, rotaciones y valores de escala a ser aplicados a un objeto. Por ejemplo: 

myMat = Base.Matrix()
myMat.move(Base.Vector(2,0,0))
myMat.rotateZ(math.pi/2)

Nota: Las matrices de FreeCAD funcionan en radianes. También, casi todas las operaciones de matrices que toman un vector pueden tomar 3 números, así estas dos líneas hacen lo mismo: 

myMat.move(2,0,0)
myMat.move(Base.Vector(2,0,0))

Cuando nuestra matriz es establecida, podemos aplicarla a nuestra forma. FreeCAD proporciona 2 métodos para hacerlo: transformShape() y transformGeometry(). La diferencia es que con el primero, estas seguro de que no ocurrirá ninguna deformación (mira "escalando una forma" más abajo). Podemos aplicar nuestra transformación así: 

myShape.trasformShape(myMat)

o 

myShape.transformGeometry(myMat)

Escalando una forma

Escalando una forma es una operación más peligrosa porque, a diferencia de la traslación o rotación, un escalado no uniforme (con diferentes valores para los ejes X,Y y Z) puede modificar la estructura de la forma. Por ejemplo, escalando una circunferencia con un valor horizontal superior al vertical la transformará en una elipse, que se comporta matemáticamente de forma muy diferente. Para el escalado, no podemos utilizar transformShape, tenemos que usar transformGeometry(): 

myMat = Base.Matrix()
myMat.scale(2,1,1)
myShape.transformGeometry(myMat)

Operaciones Booleanas

Diferencia

La diferencia de una forma con otra se llama "corte" en el argot de OCC/FreeCAD y se hace así: 

cylinder = Part.makeCylinder(3,10,Base.Vector(0,0,0),Base.Vector(1,0,0))
sphere = Part.makeSphere(5,Base.Vector(5,0,0))
diff = cylinder.cut(sphere)

Intersección

del mismo modo, la intersección entre dos formas es denominada "común" y se hace de este modo: 

cylinder1 = Part.makeCylinder(3,10,Base.Vector(0,0,0),Base.Vector(1,0,0))
cylinder2 = Part.makeCylinder(3,10,Base.Vector(5,0,-5),Base.Vector(0,0,1))
common = cylinder1.common(cylinder2)

Unión

La unión se llama "fusión" y funciona del mismo modo: 

cylinder1 = Part.makeCylinder(3,10,Base.Vector(0,0,0),Base.Vector(1,0,0))
cylinder2 = Part.makeCylinder(3,10,Base.Vector(5,0,-5),Base.Vector(0,0,1))
fuse = cylinder1.fuse(cylinder2)

Sección

Una sección es la intersección entre una forma de un sólido y una forma de un plano. Devolverá una curva de intersección, un componente con aristas 

cylinder1 = Part.makeCylinder(3,10,Base.Vector(0,0,0),Base.Vector(1,0,0))
cylinder2 = Part.makeCylinder(3,10,Base.Vector(5,0,-5),Base.Vector(0,0,1))
section = cylinder1.section(cylinder2)
section.Wires
> []
section.Edges
> [<Edge object at 0D87CFE8>, <Edge object at 019564F8>, <Edge object at 0D998458>, 
 <Edge  object at 0D86DE18>, <Edge object at 0D9B8E80>, <Edge object at 012A3640>, 
 <Edge object at 0D8F4BB0>]

Extrusión

Extrusión es el acto de "empujar" una forma plana en determinada dirección resultando en un cuerpo sólido. Piensa en una círculo convirtiéndose en un tubo: 

circle = Part.makeCircle(10)
tube = circle.extrude(Base.Vector(0,0,2))

Si tu círculo está hueco, obtendrás un tubo hueco. Si no es hueco, obtendrás un cilindro sólido: 

wire = Part.Wire(circle)
disc = Part.makeFace(wire)
cylinder = disc.extrude(Base.Vector(0,0,2))

Exploración de formas

Puedes explorar fácilmente la estructura de datos topológicos: 

import Part
b = Part.makeBox(100,100,100)
b.Wires
w = b.Wires[0]
w
w.Wires
w.Vertexes
Part.show(w)
w.Edges
e = w.Edges[0]
e.Vertexes
v = e.Vertexes[0]
v.Point

Escribiendo las líneas de arriba en el interprete de Python, conseguirás una buena comprensión de la estructura de los objetos de piezas. Aquí, nuestro comando makeBox() crea una forma sólida. Este sólido, como todos los sólidos de piezas, contiene caras. Las caras siempre contienen contornos, que son listas de aristas que bordean la cara. Cada cara tiene al menos un contorno cerrado (puede tener más si la cara tiene huecos). En el contorno, podemos mirar en cada arista de forma separada, y dentro de cada arista, podemos ver los vértices. Las aristas rectas tienen sólo dos vértices, obviamente.

Análisis de aristas

En el caso de una arista con una curva arbitraria, es más probable que quieras hacer una discretización. En FreeCAD las aristas son parametrizadas por sus longitudes. Eso significa que puedes recorrer una arista/curva por su longitud: 

import Part
box = Part.makeBox(100,100,100)
anEdge = box.Edges[0]
print anEdge.Length

Ahora puedes acceder a un montón de propiedades de la arista utilizando la longitud como una posición. Eso significa que si la arista es de 100mm de longitud el punto inicial es y la posición final es 100. 

anEdge.tangentAt(0.0)      # tangent direction at the beginning
anEdge.valueAt(0.0)        # Point at the beginning
anEdge.valueAt(100.0)      # Point at the end of the edge
anEdge.derivative1At(50.0) # first derivative of the curve in the middle
anEdge.derivative2At(50.0) # second derivative of the curve in the middle
anEdge.derivative3At(50.0) # third derivative of the curve in the middle
anEdge.centerOfCurvatureAt(50) # center of the curvature for that position
anEdge.curvatureAt(50.0)   # the curvature
anEdge.normalAt(50)        # normal vector at that position (if defined)

Utilizando la selección

Aquí vemos ahora cómo podemos utilizar la selección que el usuario hizo en la vista. Antes de nada creamos un cubo y lo mostramos en la vista 

import Part
Part.show(Part.makeBox(100,100,100))
Gui.SendMsgToActiveView("ViewFit")

Selecciona ahora algunas caras o aristas. Con este archivo de guión puedes iterar todos los objetos seleccionados y sus subelementos: 

for o in Gui.Selection.getSelectionEx():
	print o.ObjectName
	for s in o.SubElementNames:
		print "name: ",s
	for s in o.SubObjects:
		print "object: ",s

Selecciona algunas aristas y este archivo de guión calculará la longitud: 

length = 0.0
for o in Gui.Selection.getSelectionEx():
	for s in o.SubObjects:
		length += s.Length
print "Length of the selected edges:" ,length

Examen completo: La botella OCC

Un ejemplo típico encontrado en la página de primeros pasos de OpenCasCade es cómo construir una botella. Este es un buen ejercicio también para FreeCAD. En realidad, puedes seguir nuestro ejemplo de abajo y la página de OCC simultáneamente, comprenderás bien cómo están implementadas las estructuras de OCC en FreeCAD. El archivo de guión completo de abajo está también incluido en la instalación de FreeCAD (dentro del directorio Mod/Part) y puede llamarse desde el interprete de Python escribiendo: 

import Part
import MakeBottle
bottle = MakeBottle.makeBottle()
Part.show(bottle)

El archivo de guión completo

Aquí está el archivo de guión completo MakeBottle: 

import Part, FreeCAD, math
from FreeCAD import Base

def makeBottle(myWidth=50.0, myHeight=70.0, myThickness=30.0):
   aPnt1=Base.Vector(-myWidth/2.,0,0)
   aPnt2=Base.Vector(-myWidth/2.,-myThickness/4.,0)
   aPnt3=Base.Vector(0,-myThickness/2.,0)
   aPnt4=Base.Vector(myWidth/2.,-myThickness/4.,0)
   aPnt5=Base.Vector(myWidth/2.,0,0)
   
   aArcOfCircle = Part.Arc(aPnt2,aPnt3,aPnt4)
   aSegment1=Part.Line(aPnt1,aPnt2)
   aSegment2=Part.Line(aPnt4,aPnt5)
   aEdge1=aSegment1.toShape()
   aEdge2=aArcOfCircle.toShape()
   aEdge3=aSegment2.toShape()
   aWire=Part.Wire([aEdge1,aEdge2,aEdge3])
   
   aTrsf=Base.Matrix()
   aTrsf.rotateZ(math.pi) # rotate around the z-axis
   
   aMirroredWire=aWire.transformGeometry(aTrsf)
   myWireProfile=Part.Wire([aWire,aMirroredWire])
   myFaceProfile=Part.Face(myWireProfile)
   aPrismVec=Base.Vector(0,0,myHeight)
   myBody=myFaceProfile.extrude(aPrismVec)
   myBody=myBody.makeFillet(myThickness/12.0,myBody.Edges)
   neckLocation=Base.Vector(0,0,myHeight)
   neckNormal=Base.Vector(0,0,1)
   myNeckRadius = myThickness / 4.
   myNeckHeight = myHeight / 10
   myNeck = Part.makeCylinder(myNeckRadius,myNeckHeight,neckLocation,neckNormal)	
   myBody = myBody.fuse(myNeck)
   
   faceToRemove = 0
   zMax = -1.0
   
   for xp in myBody.Faces:
       try:
           surf = xp.Surface
           if type(surf) == Part.Plane:
               z = surf.Position.z
               if z > zMax:
                   zMax = z
                   faceToRemove = xp
       except:
           continue
   
   myBody = myBody.makeThickness([faceToRemove],-myThickness/50 , 1.e-3)
   
   return myBody

Explicación detallada 

import Part, FreeCAD, math
from FreeCAD import Base

Necesitaremos, desde luego, el módulo de piezas, pero también el módulo FreeCAD.Base, que contiene estructuras básicas de FreeCAD como vectores y matrices. 

def makeBottle(myWidth=50.0, myHeight=70.0, myThickness=30.0):
   aPnt1=Base.Vector(-myWidth/2.,0,0)
   aPnt2=Base.Vector(-myWidth/2.,-myThickness/4.,0)
   aPnt3=Base.Vector(0,-myThickness/2.,0)
   aPnt4=Base.Vector(myWidth/2.,-myThickness/4.,0)
   aPnt5=Base.Vector(myWidth/2.,0,0)

Aquí definimos nuestra función makeBottle. Esta función se puede llamar sin argumentos, como hicimos arriba, en cuyo caso se utilizaran los valores por defecto para ancho, alto, y espesor. Luego, definimos un conjunto de puntos que serán utilizados para construir nuestro perfil base. 

   aArcOfCircle = Part.Arc(aPnt2,aPnt3,aPnt4)
   aSegment1=Part.Line(aPnt1,aPnt2)
   aSegment2=Part.Line(aPnt4,aPnt5)

Aquí en realidad definimos la geometría: un arco, creado por 3 puntos, y dos segmentos de línea, creados por 2 puntos. 

   aEdge1=aSegment1.toShape()
   aEdge2=aArcOfCircle.toShape()
   aEdge3=aSegment2.toShape()
   aWire=Part.Wire([aEdge1,aEdge2,aEdge3])

Recuerdas la diferencia entre geometría y formas? Aquí construimos formas a partir de nuestra geometría de construcción. 3 aristas (las aristas pueden ser rectas o curvas), luego un contorno creado a partir de dichas tres aristas. 

   aTrsf=Base.Matrix()
   aTrsf.rotateZ(math.pi) # rotate around the z-axis
   aMirroredWire=aWire.transformGeometry(aTrsf)
   myWireProfile=Part.Wire([aWire,aMirroredWire])

Hasta ahora construimos sólo medio perfil. Más sencillo que construir el perfil completo del mismo modo, simplemente podemos crear una simetría de lo que hicimos, y pegar ambas partes. Así primero creamos una matriz. Una matriz es un modo muy común para aplicar transformaciones a objetos en el mundo 3D, ya que puede contener en una estructura todas las transformaciones básicas que los objetos pueden sufrir (mover, rotar y escalar). Aquí, después de crear la matriz, creamos una simétrica, y creamos una copia de nuestro contorno con esa matriz de transformación aplicada. Ahora tenemos 2 contornos, y podemos crear un tercer contorno a partir de ellos, ya que los contornos son en realidad listas de aristas. 

   myFaceProfile=Part.Face(myWireProfile)
   aPrismVec=Base.Vector(0,0,myHeight)
   myBody=myFaceProfile.extrude(aPrismVec)
   myBody=myBody.makeFillet(myThickness/12.0,myBody.Edges)

Ahora que tenemos un contorno cerrado, se puede convertir en una cara. Una vez que tengamos una cara, podemos extruirla. Haciendo esto, creamos un sólido. Entonces aplicamos un pequeño redondeo a nuestro objeto porque queremos crear un buen diseño, no es así? 

   neckLocation=Base.Vector(0,0,myHeight)
   neckNormal=Base.Vector(0,0,1)
   myNeckRadius = myThickness / 4.
   myNeckHeight = myHeight / 10
   myNeck = Part.makeCylinder(myNeckRadius,myNeckHeight,neckLocation,neckNormal)

El cuerpo de nuestra botella está creado, aún tenemos que crear el cuello. Así que creamos un nuevo sólido, con un cilindro. 

   myBody = myBody.fuse(myNeck)

La operación de fusión, que en otras aplicaciones es llamada unión, es muy potente. Tendrá cuidado de pegar lo que necesita ser pegado y eliminar las partes que necesiten ser eliminadas. 

   return myBody

Obtenemos nuestro sólido de pieza como resultado de nuestra función. Ese sólido de pieza, como cualquier otra forma de piezas, se puede atribuir a un objeto en el documento de FreeCAD, con: 

myObject = FreeCAD.ActiveDocument.addObject("Part::Feature","myObject")
myObject.Shape = bottle

o, de forma más simple: 

Part.show(bottle)

Cargando y guardando

Existen diversas formas de guardar tu trabajo en el módulo de piezas. Puedes desde luego guardar el documento de FreeCAD, pero también puedes guardar objetos de pieza directamente en formatos de CAD comunes, como BREP, IGS, STEP y STL.

El guardado de una forma en un archivo es sencillo. Existen los métodos exportBrep(), exportIges(), exportStl() y exportStep() disponibles para todos los objetos de forma. Así, haciendo: 

import Part
s = Part.makeBox(0,0,0,10,10,10)
s.exportStep("test.stp")

se guardará nuestro cubo en un archivo STEP. Para cargar un archivo BREP, IGES o STEP, simplemente haz lo contrario: 

import Part
s = Part.Shape()
s.read("test.stp")

Observa que la importación y apertura de archivos BREP, IGES o STEP también se puede hacer directamente desde el menú Archivo -> Abrir o Archivo -> Importar, mientras que la exportación es con Archivo -> Exportar

Traducciones disponibles:

Convertir Objetos parte en mallas

La conversión de objetos de alto nivel, tales como formas de Piezas en objetos más simples como mallas es una operación bastante sencilla, en la que todas las caras de un objeto Pieza son triangularizadas. El resultado de esa triangulación (o teselado) se utiliza para construir una malla: 

#let's assume our document contains one part object
import Mesh
faces = []
shape = FreeCAD.ActiveDocument.ActiveObject.Shape
triangles = shape.tessellate(1) # the number represents the precision of the tessellation)
for tri in triangles[1]:
    face = []
    for i in range(3):
        vindex = tri[i]
        face.append(triangles[0][vindex])
    faces.append(face)
m = Mesh.Mesh(faces)
Mesh.show(m)

En ocasiones, la triangulación ofrecida por OpenCascade para algunas caras es bastante fea. Si la cara tiene un espacio de parámetros rectangular y no contiene ningún agujero o curvas de corte también puedes crear una malla por tu cuenta: 

import Mesh
def makeMeshFromFace(u,v,face):
	(a,b,c,d)=face.ParameterRange
	pts=[]
	for j in range(v):
		for i in range(u):
			s=1.0/(u-1)*(i*b+(u-1-i)*a)
			t=1.0/(v-1)*(j*d+(v-1-j)*c)
			pts.append(face.valueAt(s,t))

	mesh=Mesh.Mesh()
	for j in range(v-1):
		for i in range(u-1):
			mesh.addFacet(pts[u*j+i],pts[u*j+i+1],pts[u*(j+1)+i])
			mesh.addFacet(pts[u*(j+1)+i],pts[u*j+i+1],pts[u*(j+1)+i+1])

	return mesh

Convertir Mallas en objetos Pieza

La conversión de mallas en objetos Pieza es una operación muy importante en el trabajo de CAD, ya que a menudo se reciben datos 3D en formato de malla de otras personas o son generados con otras aplicaciones. Las mallas son muy prácticas para representar la geometría de forma libre y para grandes escenas visuales, ya que son muy ligeras. Pero, por lo general, el CAD prefiere objetos de nivel superior que llevan mucha más información, como la idea de sólidos, o caras hechas de curvas, en lugar de triángulos.

La conversión de las mallas a esos objetos de nivel superior (manejados por el Módulo de Piezas en FreeCAD) no es una operación fácil. Las mallas pueden tener miles de triángulos (por ejemplo, los generados por un escáner 3D), y si los sólidos se hacen con el mismo número de caras, serían extremadamente pesados de manipular. Así que por lo general, se desea optimizar el objeto durante la conversión.

FreeCAD actualmente ofrece dos métodos para convertir mallas en piezas. El primer método es una conversión sencilla, directa, sin ningún tipo de optimización: 

import Mesh,Part
mesh = Mesh.createTorus()
shape = Part.Shape()
shape.makeShapeFromMesh(mesh.Topology,0.05) # the second arg is the tolerance for sewing
solid = Part.makeSolid(shape)
Part.show(solid)

El segundo método ofrece la posibilidad de considerar coplanares las facetas de malla que forman entre si un pequeño ángulo. Esto permite la construcción de formas mucho más simples: 

# let's assume our document contains one Mesh object
import Mesh,Part,MeshPart
faces = []
mesh = App.ActiveDocument.ActiveObject.Mesh
segments = mesh.getPlanes(0.00001) # use rather strict tolerance here

for i in segments:
  if len(i) > 0:
     # a segment can have inner holes
     wires = MeshPart.wireFromSegment(mesh, i)
     # we assume that the exterior boundary is that one with the biggest bounding box
     if len(wires) > 0:
        ext=None
        max_length=0
        for i in wires:
           if i.BoundBox.DiagonalLength > max_length:
              max_length = i.BoundBox.DiagonalLength
              ext = i

        wires.remove(ext)
        # all interior wires mark a hole and must reverse their orientation, otherwise Part.Face fails
        for i in wires:
           i.reverse()

        # make sure that the exterior wires comes as first in the lsit
        wires.insert(0, ext)
        faces.append(Part.Face(wires))

shell=Part.Compound(faces)
Part.show(shell)
#solid = Part.Solid(Part.Shell(faces))
#Part.show(solid)


Traducciones disponibles:

FreeCAD es, en esencia, un collage de varias bibliotecas muy potentes, siendo las más importantes openCascade, para la gestión y construcción de la geometría, Coin3d para visualizar esa geometría, y Qt para poner todo esto en una bonita interfaz gráfica de usuario (GUI).

La geometría que aparece en las vistas 3D de FreeCAD son renderizadas por la biblioteca Coin3D. Coin3D es una implementación del estandard OpenInventor. El software OpenCascade también proporciona la misma funcionalidad, pero se decidió, al comenzar el desarrollo de FreeCAD, no utilizar el visor de OpenCascade, sino cambiar al software Coin3D, por tener mejor rendimiento. Un buen modo de aprender sobre esa librería es el libro Open Inventor Mentor.


OpenInventor es en realidad un lenguaje de descripción de escena 3D. La escena descrita en openInventor es seguidamente renderizada en la pantalla con OpenGL. Coin3d se encarga de hacer esto, por lo que el programador no tiene que lidiar con complejas llamadas a OpenGL, bastará con que le proporcione código OpenInventor válido. La gran ventaja es que openInventor es un estándard muy bien conocido y bien documentado.

Uno de los trabajos mas inportantes que FreeCAD hace por ti es, básicamente, traducir la información de geometría OpenCascade al idioma de openInventor.

OpenInventor describe una escena 3D en forma de una escena gráfica (scenegraph), como la siguiente:

Image:Scenegraph.gif image from Inventor mentor

Una escena gráfica de openInventor describe todo lo que es parte de una escena 3D, como la geometría, colores, materiales, luces, etc, y organiza todos los datos en una estructura cómoda y clara. Todo puede agruparse en sub-estructuras, lo que te permite organizar los contenidos de tu escena más o menos de la forma que quiera. He aquí un ejemplo de un archivo de openInventor: 

#Inventor V2.0 ascii

Separator { 
    RotationXYZ {	
       axis Z
       angle 0
    }
    Transform {
       translation 0 0 0.5
    }
    Separator {	
       Material {
          diffuseColor 0.05 0.05 0.05
       }
       Transform {
          rotation 1 0 0 1.5708
          scaleFactor 0.2 0.5 0.2
       }
       Cylinder {
       }
    }
}

Como puedes ver, la estructura es muy simple. Utiliza separadores para organizar los datos en bloques, parecido a como harías al organizar tus archivos en carpetas. Cada declaración afecta a lo que viene después, por ejemplo los dos primeros puntos de nuestro separador raíz son una rotación y una traslación, todo ello afectará al siguiente elemento, que es un separador. En ese separador, se define un material y otra transformación. Nuestro cilindro por lo tanto se verá afectado por las dos transformaciones, la que le fue aplicada directamente, y la que se aplicó al separador que le contiene.

También tenemos muchos otros tipos de elementos para organizar nuestra escena, como los grupos, conmutadores o anotaciones. Podemos definir materiales muy complejos para nuestros objetos, con el color, las texturas, los modos de sombreado y transparencia. También podemos definir las luces, cámaras, e incluso movimiento. También es posible integrar pedazos de secuencias de comandos en los archivos de openInventor, para definir comportamientos más complejos.

Si estás interesado en aprender más sobre openInventor, vete directamente a su referencia más famosa, Inventor mentor.

En FreeCAD, normalmente, no es necesario interactuar directamente con la escena gráfica (scenegraph) de openInventor. Cada objeto en un documento de FreeCAD, ya sea una malla, una forma de pieza o cualquier otra cosa, se convierte automáticamente en código de openInventor y se inserta en la escena gráfica (scenegraph) principal que aparecen en una vista 3D. Esa escena gráfica se actualiza continuamente cuando se hacen modificaciones, se añaden o eliminan objetos en el documento. De hecho, cada objeto (en el espacio App) tiene un proveedor de vista (un objeto correspondiente en el espacio de la interfaz gráfica del usuario GUI), responsable de la expedición de código de openInventor.

Pero poder acceder a la escena gráfica directamente tiene muchas ventajas. Por ejemplo, puedes cambiar temporalmente la apariencia de un objeto, o podemos agregar objetos a la escena que no tienen existencia real en el documento de FreeCAD, como la geometría constructiva, ayudantes, sugerencias o herramientas gráficas como manipuladores o información en pantalla.

FreeCAD cuenta con varias herramientas para ver o modificar código de openInventor. Por ejemplo, el código de Python siguiente muestra la representación en openInventor de un objeto seleccionado: 

obj = FreeCAD.ActiveDocument.ActiveObject
viewprovider = obj.ViewObject 
print viewprovider.toString()

Pero también tenemos un módulo de Python que permite un acceso completo a todo lo controlado por Coin3d, como la escena gráfica (scenegraph) de FreeCAD. Sigue leyendo en Pivy.

Traducciones disponibles:

Pivy es una biblioteca para enlazar Python con Coin3d, la biblioteca de renderizado-3D utilizada con FreeCAD. Cuando se importa en un intérprete de Python en ejecución, permite dialogar directamente con cualquier escenas gráficas (scenegraphs) de Coin3d en ejecución, como las vistas 3D de FreeCAD, o incluso para crear otras nuevas. Pivy se incluye en la instalación estándar de FreeCAD.

La biblioteca de Coin se divide en varias partes, la propia Coin, para manipular escenas gráficas, y pasarelas a varios sistemas de interfaz gráfica de usuario (GUI), tales como Windows o, en nuestro caso, Qt. Esos módulos están también disponibles para Pivy, si están presentes en el sistema. El módulo Coin está siempre presente, y es lo que vamos a utilizar en todos los casos, y no tendrás que preocuparte de anclar nuestra pantalla 3D en ninguna interfaz, ya que FreeCAD ya lo ha hecho por si mismo. Todo lo que necesitamos hacer es esto: 

from pivy import coin

Acceso y modificación de la escena gráfica

Vimos en la Página de escenas gráficas cómo se organiza una típica escena de Coin. Todo lo que aparece en una vista 3D de FreeCAD es una escena gráfica de Coin, organizada de la misma manera. Tenemos un nodo raíz, y todos los objetos en la pantalla son sus hijos.

FreeCAD tiene una sencilla forma de acceder al nodo raíz de una escenas gráficas en vista 3D: 

sg = FreeCADGui.ActiveDocument.ActiveView.getSceneGraph()
print sg

Esto devolverá el nodo raíz: 

<pivy.coin.SoSelection; proxy of <Swig Object of type 'SoSelection *' at 0x360cb60> >

Podemos inspeccionar los elementos secundarios inmediatos de nuestra escena: 

for node in sg.getChildren():
    print node

Algunos de esos nodos, tales como SoSeparators o SoGroups, pueden tener sus propios hijos. La lista completa de los objetos de Coin disponibles se puede encontrar en la documentación oficial de Coin.

Ahora vamos a tratar de añadir algo a nuestra escena gráfica. Vamos a añadir un bonito cubo rojo: 

col = coin.SoBaseColor()
col.rgb=(1,0,0)
cub = coin.SoCube()
myCustomNode = coin.SoSeparator()
myCustomNode.addChild(col)
myCustomNode.addChild(cub)
sg.addChild(myCustomNode)

y aquí está nuestro (magnífico) cubo rojo. Ahora, vamos a probar esto: 

col.rgb=(1,1,0)

¿Ves? todo se mantiene accesible y modificable sobre la marcha. No hay necesidad de volver a calcular o dibujar cualquier cosa, Coin se encarga de todo. Puedes agregar cosas a la escena gráfica, cambiar las propiedades, ocultar cosas, mostrar objetos temporales, cualquier cosa. Por supuesto, esto sólo afecta a la pantalla en la vista 3D. Esa pantalla se vuelve a calcular por FreeCAD al abrir el archivo, y cuando un objeto necesita recalcularse. Por lo tanto, si cambias el aspecto de un objeto FreeCAD existente, esos cambios se perderán si el objeto se vuelve a recalcular o cuando se vuelve a abrir el archivo.

Una de las claves para trabajar con escenas gráficas en los archivos de guión es poder tener acceso cuando sea necesario a ciertas propiedades de los nodos que has añadido. Por ejemplo, si quisieramos mover nuestro cubo, habríamos añadido un nodo SoTranslation a nuestro nodo de referencia, y se vería así: 

col = coin.SoBaseColor()
col.rgb=(1,0,0)
trans = coin.SoTranslation()
trans.translation.setValue([0,0,0])
cub = coin.SoCube()
myCustomNode = coin.SoSeparator()
myCustomNode.addChild(col)
mtCustomNode.addChild(trans)
myCustomNode.addChild(cub)
sg.addChild(myCustomNode)

Recuerda que en una escena gráfica de openInventor, el orden es importante. Un nodo afecta a lo que viene a continuación, por lo que puedes decir algo como: color rojo, cubo, color amarillo, esfera, y obtendrás un cubo rojo y una esfera amarilla. Si ahora añadimos la traslación a nuestro nodo de referencia existente, eso llegaría después del cubo, y no lo afectaría. Si lo hubieramos insertado cuando lo creamos, como aquí arriba, ahora podríamos hacer: 

trans.translation.setValue([2,0,0])

Y nuestro cubo saltaría 2 unidades a la derecha. Por último, para eliminar algo se hace con: 

sg.removeChild(myCustomNode)

La utilización de mecanismos de devolución de llamada

Un callback mechanism (mecanismo de devolución de llamada) es un sistema que permite a una biblioteca que se está utilizando, como la biblioteca Coin, que le devuelva la llamada, es decir, que llame a una función específica de tu objeto de Python ejecutado actualmente. Esto es muy útil, porque de esa manera Coin puede avisarte si algún evento específico se produce en la escena. Coin pueden ver cosas muy diferentes, como la posición del ratón, clics en un botón del ratón, las teclas del teclado que son pulsadas y muchas otras cosas.

FreeCAD cuenta con una sencilla manera de utilizar devoluciones de llamada de este tipo: 

class ButtonTest:
  def __init__(self):
    self.view = FreeCADGui.ActiveDocument.ActiveView
    self.callback = self.view.addEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.getMouseClick) 
  def getMouseClick(self,event_cb):
    event = event_cb.getEvent()
    if event.getState() == SoMouseButtonEvent.DOWN:
      print "Alert!!! A mouse button has been improperly clicked!!!"
      self.view.removeEventCallbackSWIG(SoMouseButtonEvent.getClassTypeId(),self.callback) 

ButtonTest()

La devolución de llamada tiene que ser iniciada por un objeto, y ese objeto debe estar todavía en ejecución cuando la devolución de llamada se produzca. Mira también una lista completa de los eventos posibles y sus parámetros, o la documentación oficial de Coin.

Documentación

Lamentablemente Pivy aún no tiene una documentación formal, pero como es una traducción exacta de Coin, puedes utilizar con seguridad la documentación de Coin como referencia, y utilizar el estilo de Python en lugar del estilo de C++ (por ejemplo, SoFile::getClassTypeId() se escribiría en Pivy como: SoFile.getClassId() )

Traducciones disponibles:

PyQt es un módulo de Python que permite a las aplicaciones en Python crear, acceder y modificar aplicaciones Qt. Se puede utilizar por ejemplo para crear tus propios programas de Qt en Python, o para acceder y modificar la interfaz de una aplicación Qt en ejecución, como FreeCAD.

Al utilizar el módulo de PyQt desde el interior de FreeCAD, se tiene un control total sobre su interfaz. Por ejemplo, puedes:

  • Añadir tus propios paneles, complementos (widgets) y barras de herramientas
  • Añadir u ocultar los elementos en los paneles existentes
  • Cambiar, redirigir o agregar conexiones entre todos los elementos

PyQt tiene una extensa documentación del API, y hay muchos tutoriales en la red que te enseñan cómo funciona.

Si quieres trabajar en la interfaz de FreeCAD, lo primero que debes hacer es crear una referencia a la ventana principal de FreeCAD : 

import sys
from PyQt4 import QtGui
app = QtGui.qApp
mw = app.activeWindow()

A continuación, puedes navegar por ejemplo a través de todos los complementos (widgets) de la interfaz: 

for child in mw.children():
   print 'widget name = ', child.objectName(), ', widget type = ', child

Los complementos (widgets) en una interfaz Qt se suelen anidar en otros complementos o (widgets) "contenedores", de modo que los hijos de nuestra ventana principal pueden contener otros hijos. Dependiendo del tipo de complemento (widget), hay un montón de cosas que puedes hacer. Comprueba la documentación de la API para ver lo que es posible.

Agregar un nuevo complemento (widget), por ejemplo un dockWidget (que puede ser colocado en uno de los paneles laterales de FreeCAD), es sencillo: 

myWidget = QtGui.QDockWidget()
mw.addDockWidget(QtCore.Qt.RightDockWidgetArea,myWidget)

A continuación, podrías agregar cosas directamente a tu complemento (widget): 

  myWidget.setObjectName("my Nice New Widget")
  myWidget.resize(QtCore.QSize(300,100)) # sets size of the widget
  label = QtGui.QLabel("Hello World", myWidget) # creates a label
  label.setGeometry(QtCore.QRect(50,50,200,24)) # sets its size
  label.setObjectName("myLabel") # sets its name, so it can be found by name

Sin embargo, es preferible un método que consiste en crear un objeto de interfaz de usuario (UI) que hará todo el trabajo de la configuración del complemento (widget) a la vez. La gran ventaja es que tales objetos de interfaz de usuario puede ser creados gráficamente con el programa Qt Designer. Un objeto típico generado por Qt Designer es así: 

class myWidget_Ui(object):
  def setupUi(self, myWidget):
    myWidget.setObjectName("my Nice New Widget")
    myWidget.resize(QtCore.QSize(300,100)).expandedTo(myWidget.minimumSizeHint())) # sets size of the widget

    self.label = QtGui.QLabel(myWidget) # creates a label
    self.label.setGeometry(QtCore.QRect(50,50,200,24)) # sets its size
    self.label.setObjectName("label") # sets its name, so it can be found by name

  def retranslateUi(self, draftToolbar): # built-in QT function that manages translations of widgets
    myWidget.setWindowTitle(QtGui.QApplication.translate("myWidget", "My Widget", None, QtGui.QApplication.UnicodeUTF8))
    self.label.setText(QtGui.QApplication.translate("myWidget", "Welcome to my new widget!", None, QtGui.QApplication.UnicodeUTF8))

Para utilizarlo, sólo tienes que aplicarlo a tu recién creado complemento (widget) de este modo: 

myNewFreeCADWidget = QtGui.QDockWidget() # create a new dckwidget
myNewFreeCADWidget.ui = myWidget_Ui() # load the Ui script
myNewFreeCADWidget.ui.setupUi(myNewFreeCADWidget) # setup the ui
FCmw.addDockWidget(QtCore.Qt.RightDockWidgetArea,myNewFreeCADWidget) # add the widget to the main window
Traducciones disponibles:

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.


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 cPickle module.\
                Since we have some un-pickable here -- the Coin stuff -- we must define this method\
                to return a tuple of all pickable objects or None."
		return None
 
	def __setstate__(self,state):
		"When restoring the pickled object from document we have the chance to set some internals here.
                Since no data were pickled 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: 

a.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.

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.

Trabajar con formas simples

Si tu objeto paramétrico saca simplemente una forma, no es necesario utilizar un objeto proveedor de vista. La forma se mostrará en la representación de formas de FreeCAD: 

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()
Traducciones disponibles:

FreeCAD tiene la asombrosa capacidad de poder importarse como un módulo de Python en otros programas o en una consola independiente de Python, junto con todos sus módulos y componentes. Incluso es posible importar el GUI de FreeCAD como módulo Python (aunque con algunas restricciones).

Usando FreeCAD sin interfaz gráfica de usuario GUI

Una primera, directa, fácil y útil aplicación que puedes hacer de esto es para importar documentos de FreeCAD en tu programa. En el siguiente ejemplo, vamos a importar la geometría de la pieza de un documento de FreeCAD en Blender. Aquí está el archivo de guión completo. Espero que te impresione por su sencillez: 

FREECADPATH = '/opt/FreeCAD/lib' # path to your FreeCAD.so or FreeCAD.dll file
import Blender, sys
sys.path.append(FREECADPATH)

def import_fcstd(filename):
   try:
       import FreeCAD
   except ValueError:
       Blender.Draw.PupMenu('Error%t|FreeCAD library not found. Please check the FREECADPATH variable in the import script is correct')
   else:
       scene = Blender.Scene.GetCurrent()
       import Part
       doc = FreeCAD.open(filename)
       objects = doc.Objects
       for ob in objects:
           if ob.Type[:4] == 'Part':
               shape = ob.Shape
               if shape.Faces:
                   mesh = Blender.Mesh.New()
                   rawdata = shape.tessellate(1)
                   for v in rawdata[0]:
                       mesh.verts.append((v.x,v.y,v.z))
                   for f in rawdata[1]:
                       mesh.faces.append.append(f)
                   scene.objects.new(mesh,ob.Name)
       Blender.Redraw()

def main():
   Blender.Window.FileSelector(import_fcstd, 'IMPORT FCSTD', 
                       Blender.sys.makename(ext='.fcstd'))    

# This lets you import the script without running it
if __name__=='__main__':
   main()

La primera parte, importante, es estar seguro de que Python encontrará nuestra biblioteca de FreeCAD. Una vez que la encuentra, todos los módulos de FreeCAD como el de Pieza (que también utilizaremos) estarán disponibles de forma automática. Así que, simplemente, tomamos la variable sys.path, que es donde Python busca sus módulos, y añadimos la ruta de acceso de FreeCAD lib. Esta modificación es sólo temporal, y se perderá cuando cerremos nuestro intérprete de Python. Otra forma podría ser hacer un enlace a tu librería de FreeCAD en una de las rutas de búsqueda de Python. Yo he puesto la ruta en una constante (FREECADPATH), por lo que será más fácil para otro usuario del archivo de guión adaptarlo a su propio sistema.

Una vez que estamos seguros de que la biblioteca se carga (la secuencia try/except), podemos trabajar con FreeCAD del mismo modo que lo haríamos en el propio intérprete de Python que tiene FreeCAD. Abrimos el documento de FreeCAD que nos pasa la función main(), y hacemos una lista de sus objetos. Luego, como hemos escogido ocuparnos sólo de la geometría de la Pieza, verificamos que la propiesdad Type de cada objeto contiene "Parte", y despues lo teselamos.

El proceso de teselado elabora una lista de vértices y una lista de caras definidas por vértices índexados. Esto es perfecto, ya que es exactamente del mismo modo se definen las mallas en Blender. Por lo tanto, nuestra tarea es ridículamente simple, sólo tienes que añadir los contenidos de ambas listas a los vértices y caras de una malla de Blender. Cuando todo esté hecho, volvemos a dibujar la pantalla, y eso es todo!

Por supuesto, como este archivo de guión es muy simple (de hecho hice uno más avanzados aquí), es posible que desees ampliarlo, por ejemplo añadiendo la importación de objetos malla, o importando geometría de piezas que no tenga caras, o importar otros formatos de archivo de los que puede leer FreeCAD. Es posible que también desees exportar la geometría a un documento de FreeCAD, lo cual se puede hacer de la misma manera. Es posible que también quieras construir un cuadro de diálogo, con el que el usuario pueda elegir qué importar, etc .. La belleza de todo esto reside realmente en el hecho de que tu dejas a FreeCAD hacer el trabajo en la sombra, mientras que la presentación de los resultados se hace en el programa de tu elección.

Uso de FreeCAD con interfaz gráfica de usuario GUI

Desde la versión 4.2, Qt tiene capacidad para incrustar plugins Qt dependientes del interfaz gráfica de usuario GUI en aplicaciones host (anfitrión) no-Qt y compartir el bucle de eventos del host (anfitrión).

En concreto, para FreeCAD esto significa que puede ser importado (incrustado) con toda su GUI (interfaz de usuario) dentro de otra aplicación (host), con lo que desde la aplicación host se tiene el control total sobre FreeCAD.

El código en Python para lograr todo eso tiene sólo dos líneas 

import FreeCADGui 
FreeCADGui.showMainWindow()

Si la aplicación host se basa en Qt, entonces esta solución debería funcionar en todas las plataformas que soporte Qt. Sin embargo, el anfitrión debe vincularse a la misma versión de Qt que FreeCAD porque de lo contrario podrías obtener errores de ejecución inesperados.

Para aplicaciones que no son Qt, sin embargo, hay algunas limitaciones que debes tener en cuenta. Esta solución probablemente no funcionará con todos los demás toolkits. Para Windows funcionará siempre y cuando la aplicación host se base directamente en Win32 o en cualquier otro kit que use internamente el API Win32 como wxWidgets, MFC o WinForms. Para hacerlo funcionar bajo X11, la aplicación host debe vincularse a la biblioteca "glib".

Ten en cuenta, por supuesto, que para cualquier aplicación de consola, esta solución no funciona porque no hay ningún bucle de eventos en ejecución.


Traducciones disponibles:

Esta página contiene ejemplos, pedazos, trozos de código de Python en FreeCAD recogidos de experiencias de los usuarios y las discusiones en los foros. Lee y utilízala como punto de partida para tus propios archivos de guión ...


Un típico archivo InitGui.py

Cada módulo debe contener, además de tu archivo del módulo principal, un archivo InitGui.py, responsable de insertar el módulo en la interfaz GUI principal. Este es un ejemplo de uno sencillo: 

class ScriptWorkbench (Workbench): 
    MenuText = "Scripts"
    def Initialize(self):
        import Scripts # assuming Scripts.py is your module
        list = ["Script_Cmd"] # That list must contain command names, that can be defined in Scripts.py
        self.appendToolbar("My Scripts",list) 
        
Gui.addWorkbench(ScriptWorkbench())

Un típico archivo de módulo

Este es un ejemplo de un archivo de módulo principal, que contiene todo lo que tu módulo hace. Es el archivo Scripts.py invocado por el ejemplo anterior. Puedes tener en él todos tus comandos personalizados. 


import FreeCAD, FreeCADGui 

class ScriptCmd: 
   def Activated(self): 
       # Here your write what your ScriptCmd does...
       FreeCAD.Console.PrintMessage('Hello, World!')
   def GetResources(self): 
       return {'Pixmap' : 'path_to_an_icon/myicon.png', 'MenuText': 'Short text', 'ToolTip': 'More detailed text'} 
      
FreeCADGui.addCommand('Script_Cmd', ScriptCmd())

Importar un nuevo tipo de archivo

Hacer un importador para un nuevo tipo de archivo en FreeCAD es fácil. FreeCAD no considera que importes datos de un documento abierto, sino que simplemente puede abrir directamente el nuevo tipo de archivo. Así que, lo qué tienes que hacer es añadir la nueva extensión de archivo a la lista de las extensiones conocidas de FreeCAD, y escribir el código que leerá el archivo, y crear los objetos de FreeCAD que desees.

Esta línea debe añadirse al archivo InitGui.py para agregar la nueva extensión de archivo a la lista: 

# Assumes Import_Ext.py is the file that has the code for opening and reading .ext files
FreeCAD.addImportType("Your new File Type (*.ext)","Import_Ext")

Y despues en el archivo Import_Ext.py : 

def open(filename): 
   doc=App.newDocument()
   # here you do all what is needed with filename, read, classify data, create corresponding FreeCAD objects
   doc.recompute()

Para exportar tu documentno a algún nuevo tipo de archivo, se haría del mismo modo, salvo que usarías: 

FreeCAD.addExportType("Your new File Type (*.ext)","Export_Ext")

Añadir una linea

Una línea simplemente tiene 2 puntos. 

import Part,PartGui 
doc=App.activeDocument() 
# add a line element to the document and set its points 
l=Part.Line()
l.StartPoint=(0.0,0.0,0.0)
l.EndPoint=(1.0,1.0,1.0)
doc.addObject("Part::Feature","Line").Shape=l.toShape() 
doc.recompute()

Añadir un polígono

Un polígono es simplemente un conjunto de segmentos de línea concetados (una polilínea en AutoCAD). No tiene que ser necesariamente cerrado. 

import Part,PartGui 
doc=App.activeDocument()
n=list() 
# create a 3D vector, set its coordinates and add it to the list 
v=App.Vector(0,0,0) 
n.append(v) 
v=App.Vector(10,0,0) 
n.append(v) 
#... repeat for all nodes 
# Create a polygon object and set its nodes 
p=doc.addObject("Part::Polygon","Polygon") 
p.Nodes=n 
doc.recompute()

Añadiendo y quitando un objeto en un grupo 

doc=App.activeDocument() 
grp=doc.addObject("App::DocumentObjectGroup", "Group") 
lin=doc.addObject("Part::Feature", "Line")
grp.addObject(lin) # adds the lin object to the group grp
grp.removeObject(lin) # removes the lin object from the group grp

Nota: También puedes añadir grupos a otros grupos...

Añadir una malla 

import Mesh
doc=App.activeDocument()
# create a new empty mesh
m = Mesh.Mesh()
# build up box out of 12 facets
m.addFacet(0.0,0.0,0.0, 0.0,0.0,1.0, 0.0,1.0,1.0)
m.addFacet(0.0,0.0,0.0, 0.0,1.0,1.0, 0.0,1.0,0.0)
m.addFacet(0.0,0.0,0.0, 1.0,0.0,0.0, 1.0,0.0,1.0)
m.addFacet(0.0,0.0,0.0, 1.0,0.0,1.0, 0.0,0.0,1.0)
m.addFacet(0.0,0.0,0.0, 0.0,1.0,0.0, 1.0,1.0,0.0)
m.addFacet(0.0,0.0,0.0, 1.0,1.0,0.0, 1.0,0.0,0.0)
m.addFacet(0.0,1.0,0.0, 0.0,1.0,1.0, 1.0,1.0,1.0)
m.addFacet(0.0,1.0,0.0, 1.0,1.0,1.0, 1.0,1.0,0.0)
m.addFacet(0.0,1.0,1.0, 0.0,0.0,1.0, 1.0,0.0,1.0)
m.addFacet(0.0,1.0,1.0, 1.0,0.0,1.0, 1.0,1.0,1.0)
m.addFacet(1.0,1.0,0.0, 1.0,1.0,1.0, 1.0,0.0,1.0)
m.addFacet(1.0,1.0,0.0, 1.0,0.0,1.0, 1.0,0.0,0.0)
# scale to a edge langth of 100
m.scale(100.0)
# add the mesh to the active document
me=doc.addObject("Mesh::Feature","Cube")
me.Mesh=m

Añadiendo un arco o un círculo 

import Part
doc = App.activeDocument()
c = Part.Circle() 
c.Radius=10.0  
f = doc.addObject("Part::Feature", "Circle") # create a document with a circle feature 
f.Shape = c.toShape() # Assign the circle shape to the shape property 
doc.recompute()

Accediendo y cambiando la representación de un objeto

Cada objeto en un documento de FreeCAD tiene asociado un objeto de representación de la vista, que almacena todos los parámetros que definen la forma en que el objeto aparece, tales como el color, ancho de línea, etc .. 

gad=Gui.activeDocument()   # access the active document containing all 
                          # view representations of the features in the
                          # corresponding App document 

v=gad.getObject("Cube")    # access the view representation to the Mesh feature 'Cube' 
v.ShapeColor               # prints the color to the console 
v.ShapeColor=(1.0,1.0,1.0) # sets the shape color to white

Observación de Eventos del ratón en el visor 3D a través de Python

La estructura de Inventor permite añadir uno o más nodos de devolución de llamada al escenario gráfico del visor. De forma predeterminada en FreeCAD se instala un nodo de devolución de llamada por cada visor lo que permite añadir funciones C++ globales o estáticas. En el caso de la pasarela Python se han incluido algunos métodos para hacer uso de esta técnica dentro del código Python. 

App.newDocument()
v=Gui.activeDocument().activeView()

#This class logs any mouse button events. As the registered callback function fires twice for 'down' and
#'up' events we need a boolean flag to handle this.
class ViewObserver:
   def logPosition(self, info):
       down = (info["State"] == "DOWN")
       pos = info["Position"]
       if (down):
           FreeCAD.Console.PrintMessage("Clicked on position: ("+str(pos[0])+", "+str(pos[1])+")\n")
      
o = ViewObserver()
c = v.addEventCallback("SoMouseButtonEvent",o.logPosition)

Ahora, pulsa en algún lugar en la zona del visor 3D y observa los mensajes en la ventana de resultados. Para finalizar la observación sólo llama 

v.removeEventCallback("SoMouseButtonEvent",c)

Se soportan los siguientes tipos de eventos:

  • SoEvent -- Todo tipo de eventos
  • SoButtonEvent -- Todos los eventos de los botones del ratón y del teclado
  • SoLocation2Event -- Eventos de movimiento 2D (normalmente movimientos del ratón)
  • SoMotion3Event -- Eventos de movimiento 3D (normalmente del spaceball)
  • SoKeyboradEvent -- Eventos de pulsar y soltar teclas
  • SoMouseButtonEvent -- Eventos de presionar y soltar los botones del ratón
  • SoSpaceballButtonEvent -- Eventos de presionar y soltar los botones del spaceball

La función de Python que se puede registrar con addEventCallback () espera un diccionario. Dependiendo del evento observado, el diccionario puede contener diferentes claves.

En todos los eventos existen las siguientes claves:

  • Type -- El nombre del tipo de evento i.e. SoMouseEvent, SoLocation2Event, ...
  • Time -- La hora actual como una cadena de texto
  • Position -- Una dupla de dos enteros, con la posición del ratón
  • ShiftDown -- Un booleano, true si la tecla Shift estaba presionada y false en caso contrario
  • CtrlDown -- Un booleano, true si la tecla Ctrl estaba presionada y false en caso contrario
  • AltDown -- Un booleano, true si la tecla Alt estaba presionada y false en caso contrario


Para los eventos de botones, (tanto del teclado, como del ratón o de un spaceball):

  • State -- Una cadena de texto 'UP' si el botón no estaba presionado, 'DOWN' si estaba presionado o 'UNKNOWN' para cualquier otro caso

Para eventos de teclado:

  • Key -- Un carácter de la tecla presionada

Para eventos de botón de ratón

  • Button -- El botón presionado, podría ser BUTTON1, ..., BUTTON5 o ANY

Para eventos de spaceball:

  • Button -- El botón presionado, podría ser BUTTON1, ..., BUTTON7 o ANY

Y por último, eventos de movimiento:

  • Translation -- Una tripla de tres números de coma flotante
  • Rotation -- Una cuádrupla para la rotación, i.e. a tupla de cuatro números de coma flotante

Manipular escenario gráfico en Python

También es posible obtener y cambiar el escenario gráfico en Python, con el módulo 'Pivy' - una pasarela de Python para Coin. 

from pivy.coin import *                # load the pivy module
view = Gui.ActiveDocument.ActiveView   # get the active viewer
root = view.getSceneGraph()            # the root is an SoSeparator node
root.addChild(SoCube())
view.fitAll()

La API en Python de Pivy está creada utilizando la herramienta de SWIG. En FreeCAD se usan algunos nodos auto-escritos, que no pueden crearse directamente en Python. Sin embargo, es posible crear un nodo por su nombre interno. Se puede crear una instancia del tipo "SoFCSelection" con 

type = SoType.fromName("SoFCSelection")
node = type.createInstance()

Añadir y eliminar objetos al/del escenario gráfico

La adición de nuevos nodos al escenario gráfico se puede hacer de esta manera. Ten cuidado de añadir siempre un SoSeparator para contener la geometría, las coordenadas y la información de materiales de un mismo objeto. En el ejemplo siguiente se agrega una línea roja desde (0,0,0) a (10,0,0): 

from pivy import coin
sg = Gui.ActiveDocument.ActiveView.getSceneGraph()
co = coin.SoCoordinate3()
pts = [[0,0,0],[10,0,0]]
co.point.setValues(0,len(pts),pts)
ma = coin.SoBaseColor()
ma.rgb = (1,0,0)
li = coin.SoLineSet()
li.numVertices.setValue(2)
no = coin.SoSeparator()
no.addChild(co)
no.addChild(ma)
no.addChild(li)
sg.addChild(no)

Para quitarlo, simplemente escribe: 

sg.removeChild(no)

Añadiendo widgets o complementos personalizados a la interfaz

Puedes crear widgets personalizados con Qt designer, transformarlos es archivos de guión en Python, y luego cargarlos en la interfaz de FreeCAD con PyQt4.

El código de Python producido por el compilador-UI de python (la herramienta que convierte archivos .UI de Qt-designer en código de Python) tiene, en general, este aspecto (es simple, también puedes escribir el código directamente en Python): 

class myWidget_Ui(object):
 def setupUi(self, myWidget):
   myWidget.setObjectName("my Nice New Widget")
   myWidget.resize(QtCore.QSize(QtCore.QRect(0,0,300,100).size()).expandedTo(myWidget.minimumSizeHint())) # sets size of the widget

   self.label = QtGui.QLabel(myWidget) # creates a label
   self.label.setGeometry(QtCore.QRect(50,50,200,24)) # sets its size
   self.label.setObjectName("label") # sets its name, so it can be found by name

 def retranslateUi(self, draftToolbar): # built-in QT function that manages translations of widgets
   myWidget.setWindowTitle(QtGui.QApplication.translate("myWidget", "My Widget", None, QtGui.QApplication.UnicodeUTF8))
   self.label.setText(QtGui.QApplication.translate("myWidget", "Welcome to my new widget!", None, QtGui.QApplication.UnicodeUTF8))

Despues, todo lo que necesitas hacer es crear una referencia a la ventana Qt de FreeCAD, insertar un widget personalizado en ella, y "transformar" ese widget en el tuyo con el código UI que acabas de hacer: 

 app = QtGui.qApp
 FCmw = app.activeWindow() # the active qt window, = the freecad window since we are inside it
 myNewFreeCADWidget = QtGui.QDockWidget() # create a new dckwidget
 myNewFreeCADWidget.ui = myWidget_Ui() # load the Ui script
 myNewFreeCADWidget.ui.setupUi(myNewFreeCADWidget) # setup the ui
 FCmw.addDockWidget(QtCore.Qt.RightDockWidgetArea,myNewFreeCADWidget) # add the widget to the main window

Añadiendo una pestaña al Combo View

El siguiente código te permite añadir una pestaña al ComboView de FreeCAD, además de las pestañas "Proyecto" y "Tareas". Utiliza también el módulo UIC para cargar un archivo UI directamente en esa pestaña. 

from PyQt4 import QtGui,QtCore
from PyQt4 import uic
#from PySide import QtGui,QtCore

def getMainWindow():
   "returns the main window"
   # using QtGui.qApp.activeWindow() isn't very reliable because if another
   # widget than the mainwindow is active (e.g. a dialog) the wrong widget is
   # returned
   toplevel = QtGui.qApp.topLevelWidgets()
   for i in toplevel:
       if i.metaObject().className() == "Gui::MainWindow":
           return i
   raise Exception("No main window found")

def getComboView(mw):
   dw=mw.findChildren(QtGui.QDockWidget)
   for i in dw:
       if str(i.objectName()) == "Combo View":
           return i.findChild(QtGui.QTabWidget)
   raise Exception("No tab widget found")

mw = getMainWindow()
tab = getComboView(getMainWindow())
tab2=QtGui.QDialog()
tab.addTab(tab2,"A Special Tab")
uic.loadUi("/myTaskPanelforTabs.ui",tab2)
tab2.show()

#tab.removeTab(2)

Abrir una página web personalizada

import WebGui
WebGui.openBrowser("http://www.example.com")

Obtener el contenido HTML de una página web abierta

from PyQt4 import QtGui,QtWebKit
a = QtGui.qApp
mw = a.activeWindow()
v = mw.findChild(QtWebKit.QWebFrame)
html = unicode(v.toHtml())
print html
Traducciones disponibles:

Esta página muestra cómo se puede crear funcionalidades avanzadas con Python. En este ejercicio, construiremos una nueva herramienta que dibuja una línea. Esta herramienta puede ser vinculada a un comando de FreeCAD, y ese comando se puede llamar desde cualquier elemento de la interfaz, tal como un elemento de menú o un botón de una barra de herramientas.


El archivo de guión principal

En primer lugar vamos a escribir un archivo de guión que contenga toda nuestra funcionalidad. Después, vamos a guardar esto en un archivo, e importarlo en FreeCAD, así todas las clases y funciones que escribas estarán disponibles para FreeCAD. De modo que inicia tu editor de texto favorito y escribe las siguientes líneas: 

import FreeCADGui, Part
from pivy.coin import *
class line:
 "this class will create a line after the user clicked 2 points on the screen"
 def __init__(self):
   self.view = FreeCADGui.ActiveDocument.ActiveView
   self.stack = []
   self.callback = self.view.addEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.getpoint) 
 def getpoint(self,event_cb):
   event = event_cb.getEvent()
   if event.getState() == SoMouseButtonEvent.DOWN:
     pos = event.getPosition()
     point = self.view.getPoint(pos[0],pos[1])
     self.stack.append(point)
     if len(self.stack) == 2:
       l = Part.Line(self.stack[0],self.stack[1])
       shape = l.toShape()
       Part.show(shape)
         self.view.removeEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.callback)

Explicación detallada

import Part, FreeCADGui
from pivy.coin import *

En Python, cuando desees utilizar las funciones de otro módulo, tienes que importarlo. En nuestro caso, vamos a necesitar las funciones del Módulo de Pieza, para la creación de la línea, y del módulo GUI (FreeCADGui), para acceder a la vista 3D. También necesitamos el contenido completo de la biblioteca de Coin, para que podamos utilizar directamente todos los objetos Coin, como SoMouseButtonEvent, etc .. 

class line:

Aquí definimos nuestra clase principal. ¿Por qué utilizar una clase y no una función? La razón es que necesitamos que nuestra herramienta se mantenga "viva" mientras esperamos a que el usuario haga clic en la pantalla. Una función termina cuando su tarea se ha hecho, pero un objeto (una clase se define como un objeto) se mantiene vivo hasta que se destruye.

"Esta clase va a crear una línea después de que el usuario hace clic en 2 puntos en la pantalla"

En Python, cada clase o función puede tener una cadena de descripción. Esto es particularmente útil en FreeCAD, porque cuando vas a llamar a esa clase en el intérprete, la cadena de descripción se mostrará como una nota. 

def __init__(self):

Las clases en Python siempre pueden contener una función __init__, que se ejecuta cuando la clase es llamada para crear un objeto. Por lo tanto, vamos a poner aquí todo lo que queremos que ocurra cuando nuestra herramienta línea comienza. 

self.view = FreeCADGui.ActiveDocument.ActiveView

En una clase, por lo general querrás incluir self. antes de un nombre de variable, para que sea fácilmente accesible por todas las funciones dentro y fuera de esa clase. Aquí, vamos a utilizar self.view para acceder y manipular la vista 3D activa. 

self.stack = []

Aquí creamos una lista vacía que contendrá los puntos 3D enviados por la función getpoint. 

self.callback = self.view.addEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.getpoint)

Aquí viene la parte importante: Dado que en realidad se trata de una escena Coin3d, FreeCAD utiliza el mecanismo de devolución de llamada de Coin, que permite que una función sea llamada cada vez que sucede un determinado evento de escena. En nuestro caso, estamos creando una devolución de llamada para eventos SoMouseButtonEvent, y lo conduciremos a la función getpoint. Ahora, cada vez que un botón del ratón sea pulsado o soltado, la función getpoint será ejecutada.

Ten en cuenta que también hay una alternativa a addEventCallbackPivy(), llamada addEventCallback(), que dispensa del uso de pivy. Pero como pivy es una forma muy eficaz y natural para acceder a cualquier parte de la escena de Coin, es mucho mejor usarlo tanto como se pueda! 

def getpoint(self,event_cb):

Ahora definimos la función getpoint, que se ejecutará cuando el botón del ratón se pulsa en una vista 3D. Esta función recibe un argumento, que llamaremos event_cb. A partir de este evento de devolución de llamada podemos tener acceso al objeto de evento, que contiene varias piezas de información (más información aquí). 

if event.getState() == SoMouseButtonEvent.DOWN:

La función getpoint se llamará cuando un botón del ratón sea pulsado o soltado. Pero queremos escoger un punto 3D sólo cuando se presiona (de lo contrario obtendríamos dos puntos 3D muy cerca uno del otro). Por lo tanto, debes comprobar eso aquí. 

pos = event.getPosition()

Aquí obtenemos las coordenadas de pantalla del cursor del ratón 

point = self.view.getPoint(pos[0],pos[1])

Esta función nos da un vector de FreeCAD (x,y,z) que contiene el punto 3D que se encuentra en el plano focal, justo debajo del cursor de nuestro ratón. Si estás en vista de cámara, imagina un rayo proveniente de la cámara, pasando por el cursor del ratón, y alcanzando el plano focal. Ahí está nuestro punto 3D. Si estamos en una vista ortogonal, el rayo es paralelo a la dirección de la vista. 

self.stack.append(point)

Añadimos nuestro nuevo punto a la pila 

if len(self.stack) == 2:

¿Tenemos ya suficientes puntos? si es así, entonces vamos a trazar la línea! 

l = Part.Line(self.stack[0],self.stack[1])

Aquí se utiliza la función line() del Módulo de Pieza que crea una línea a partir de dos vectores de FreeCAD. Todo lo que creamos y modificamos dentro del módulo de Pieza, se queda en el módulo de Pieza . Así, hasta ahora, hemos creado un elemento de línea. No está ligado a un objeto de nuestro documento activo, por lo que no aparece nada en la pantalla. 

shape = l.toShape()

El documento de FreeCAD sólo puede aceptar formas desde el módulo de Pieza. Las formas son el tipo más genérico del módulo de Pieza. Por lo tanto, debemos convertir nuestra línea en una forma antes de añadirla al documento. 

Part.show(shape)

El módulo de Pieza tiene una función, show(), que es muy útil ya que crea un nuevo objeto en el documento y le conecta a una forma. También podrías haber creado primero un nuevo objeto en el documento, y a continuación vincularle a la forma manualmente. 

self.view.removeEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.callback)

Como ya hemos terminado con nuestra línea, vamos a quitar el mecanismo de devolución de llamada, que consume unos preciosos ciclos de CPU.

Pruebas y Uso del archivo de guión

Ahora, vamos a guardar nuestro archivo de guión en un lugar donde el intérprete de Python de FreeCAD lo encuentre. Cuando importa los módulos, el intérprete mirará en los siguientes lugares: las rutas de instalación de Python, el directorio bin de FreeCAD, y todos los directorios de módulos FreeCAD. Por lo tanto, la mejor solución es crear un nuevo directorio en una de los FreeCAD Mod directories, y salvar nuestro script en él. Por ejemplo, vamos a hacer un directorio "MyScripts", y salvamos nuestro script como "exercise.py".

Ahora, todo está listo, vamos a empezar FreeCAD, cree un nuevo documento, y, en el intérprete de Python, ejecute: 

import exercise

Si no aparece ningún mensaje de error, eso significa que nuestro script de ejercicio se ha cargado. Ahora puede comprobar su contenido con: 

dir(exercise)


El comando dir() es un comando integrado de Python que muestra el contenido de un módulo. Podemos ver que nuestra clase line() está ahí, esperandonos. Ahora vamos a probarlo: 

exercise.line()

A continuación, haz clic dos veces en la vista 3D, y .... ¡bingo!, ¡aquí está nuestra línea! Para hacerlo de nuevo, simplemente escribe exercise.line() otra vez, y otra vez, y otra vez ... Estas contento, ¿no?

Incluyendo el archivo de guión en la interfaz de FreeCAD

Ahora, para que nuestra nueva herramienta línea sea realmente buena, debe tener un botón en la interfaz, para que no sea necesario escribir todas estas cosas cada vez. La forma más fácil es transformar nuestro nuevo directorio MyScripts en un completo entorno de FreeCAD. Es fácil, todo lo que se necesita es poner un archivo llamado InitGui.py dentro de tu directorio MyScripts. El InitGui.py contendrá las instrucciones para crear un nuevo entorno (workbench), y le añadimos nuestra nueva herramienta. Además, también habrá que transformar un poco nuestro código del ejercicio, para que la herramienta line() sea reconocida como un comando oficial de FreeCAD. Comencemos por crear un archivo InitGui.py, y escribir el siguiente código en él: 

class MyWorkbench (Workbench): 
   MenuText = "MyScripts"
   def Initialize(self):
       import exercise
       commandslist = ["line"]
       self.appendToolbar("My Scripts",commandslist)
Gui.addWorkbench(MyWorkbench())

A estas alturas, ya debes entender el archivo de guión anterior por ti mismo, supongo: Creamos una nueva clase que llamamos MyWorkbench, le damos un título (MenuText), y definimos una función initialize() que se ejecutará cuando el entorno se cargue en FreeCAD. En esa función, se carga el contenido de nuestro archivo del ejercicio, y los comandos de FreeCAD que se encuentran dentro se anexan en una lista de comandos. A continuación, hacemos una barra de herramientas llamada "Mi Scripts" y le asignamos nuestra lista de comandos. Finalmente, por supuesto, sólo tenemos una herramienta, por lo que nuestra lista de comandos contiene un solo elemento. Ahora, una vez que nuestro entorno está listo, lo añadimos a la interfaz principal.

Pero esto aún no funciona, porque un comando de FreeCAD debe estar formateado de una determinada manera para poder funcionar. Así que tendremos que transformar un poco nuestra herramienta line(). Nuestro nuevo archivo de guión exercise.py tendrá después este aspecto: 

import FreeCADGui, Part
from pivy.coin import *
class line:
 "this class will create a line after the user clicked 2 points on the screen"
 def Activated(self):
   self.view = FreeCADGui.ActiveDocument.ActiveView
   self.stack = []
   self.callback = self.view.addEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.getpoint) 
 def getpoint(self,event_cb):
   event = event_cb.getEvent()
   if event.getState() == SoMouseButtonEvent.DOWN:
     pos = event.getPosition()
     point = self.view.getPoint(pos[0],pos[1])
     self.stack.append(point)
     if len(self.stack) == 2:
       l = Part.Line(self.stack[0],self.stack[1])
       shape = l.toShape()
       Part.show(shape)
       self.view.removeEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.callback)
 def GetResources(self): 
     return {'Pixmap' : 'path_to_an_icon/line_icon.png', 'MenuText': 'Line', 'ToolTip': 'Creates a line by clicking 2 points on the screen'} 
FreeCADGui.addCommand('line', line())

Lo que hicimos aquí es transformar nuestra función __init__() en una función Activated(), porque cuando se ejecutan comandos de FreeCAD, automáticamente se ejecuta la función Activated(). También hemos añadido una función GetResources(), que informa a FreeCAD de donde puede encontrar el icono de la herramienta, y cual será el nombre y la descripción de nuestra herramienta. Cualquier imagen jpg, png o svg funcionará como un icono. Puede ser de cualquier tamaño, pero lo mejor es utilizar un tamaño que esté cerca del aspecto final, como 16x16, 24x24 o 32x32. A continuación, añadimos la clase line() como un comando oficial de FreeCAD con el método addCommand().

Eso es todo, ahora sólo hay que reiniciar FreeCAD y tendremos un agradable entorno nuevo con una nueva herramienta line() de nuestra marca!

¿Quieres más?

Si te gustó este ejercicio, ¿por qué no tratar de mejorar esta pequeña herramienta? Hay muchas cosas que se pueden hacer, como por ejemplo:

  • Agregar asistencia para los usuarios: hasta ahora hemos hecho una herramienta muy burda, el usuario podría verse un poco perdido cuando la utiliza. Se podría añadir alguna información, diciéndole qué hacer a continuación. Por ejemplo, podrías mostrar mensajes en la consola de FreeCAD. ¡Echa un vistazo en el módulo de FreeCAD.Console
  • Añadir la posibilidad de teclear de forma manual las coordenadas de los puntos 3D. Mira la función input() de Python, por ejemplo
  • Añadir la posibilidad de incluir más de 2 puntos
  • Añadir eventos para otras cosas: Ahora sólo comprobamos eventos de botón del ratón, ¿que tal si también hace algo cuando el ratón se mueva, como mostrar las coordenadas actuales?
  • Dar un nombre al objeto creado

No dudes en escribir tus preguntas o ideas en la página de discusión!

Traducciones disponibles:

En esta página vamos a mostrar cómo crear un simple letrero de diálogo con Qt Designer, la herramienta oficial de Qt para el diseño de interfaces, después lo convertiremos en código de Python, para luego utilizarlo en FreeCAD. Vamos a suponer en el ejemplo que ya sabes cómo editar y ejecutar archivos de guión de Python, y que puedes hacer cosas simples en una ventana de terminal, como navegar, etc. También debes tener, por supuesto, PyQt instalado.

Diseñar el letrero de diálogo

En las aplicaciones de CAD, el diseño de una buena interfaz de usuario (UI, User Interface) es muy importante. Casi todo lo que el usuario haga será a través de alguna parte de la interfaz: leyendo los letreros de diálogo, pulsando los botones, eligiendo entre iconos, etc. Así que es muy importante pensar cuidadosamente lo que quieres hacer, cómo deseas que el usuario se comporte, y cómo será el flujo de trabajo de tu acción.

Hay un par de conceptos que debes saber a la hora de diseñar la interfaz:

  • Letreros de diálogo Modales/no modales: Un letrero de diálogo modal aparece delante de la pantalla, deteniendo la acción de la ventana principal, obligando al usuario a responder al cuadro de diálogo, mientras que un cuadro de diálogo no modal permite seguir trabajando en la ventana principal. En algunos casos la primera opción es mejor, pero en otros casos no.
  • Identificación de lo que es necesario y lo que es opcional: Asegúrate de que el usuario sabe lo que debe hacer. Etiqueta todo con la descripción adecuada, utiliza etiquetas de información sobre el uso de las herramientas, etc.
  • Separar los comandos de los parámetros: Esto se hace generalmente con botones y cuadros de texto. El usuario sabe que al hacer clic en un botón, se produce una acción mientras que al cambiar un valor dentro de un cuadro de texto va a cambiar un parámetro en alguna parte. Hoy en día, sin embargo, los usuarios suelen conocer bien lo que es un botón, lo que es un cuadro de texto, etc. El conjunto de herramientas de interfaz que está utilizando, Qt, es el conjunto de herramientas más avanzado, y no tendrás que preocuparte mucho de hacer las cosas claras, puesto que ya va a ser muy clara por sí misma.

Así que, ahora que tenemos bien definido lo que haremos, es el momento para abrir el diseñador de Qt Designer. Diseñemos un letrero de diálogo muy sencillo, como este:

Image:Qttestdialog.jpg

Después podremos utilizar este letrero de diálogo en FreeCAD para producir un bonito plano rectangular. Puede que no veas muy útil hacer planos rectangulares, pero será fácil cambiarlo más adelante para hacer cosas más complejas. Cuando lo abras, el aspecto de Qt Designer es el siguiente:

Image:Qtdesigner-screenshot.jpg

Es muy sencillo de utilizar. En la barra de la izquierda tienes elementos que pueden ser arrastrados a tu widget. En el lado derecho tienes los paneles de propiedades mostrando todo tipo de propiedades editables de los elementos seleccionados. Comencemos ahora con la creación de un nuevo widget o complemento. Selecciona "letrero de diálogo sin botones", ya que no queremos el formato predeterminado de botones Ok/Cancelar. A continuación, arrastra sobre tu widget 3 etiquetas, una para el título, una para escribir "Altura" y otra para escribir "Ancho". Las etiquetas son textos sencillos que aparecen en tu widget, simplemente para informar al usuario. Si seleccionas una etiqueta, en la parte derecha aparecerán varias propiedades que puedes cambiar si lo deseas, como el estilo de fuente, altura, etc.

A continuación, agrega 2 LineEdits, que son cuadros de texto que el usuario puede rellenar, uno para la altura y uno para el ancho. También en este caso, podemos editar las propiedades. Por ejemplo, ¿por qué no establecer un valor predeterminado? digamos 1.00 para cada uno. De esta manera, cuando el usuario vea el letrero de diálogo, ambos campos ya estarán rellenados, y si está conforme puede pulsar el botón directamente, ahorrando un tiempo precioso. A continuación, agrega un PushButton, que es el botón que el usuario deberá pulsar después de llenar los 2 campos.

Ten en cuenta que he elegido aquí controles muy sencillos, pero Qt tiene muchas más opciones, por ejemplo, podría utilizar Spinboxes en lugar de LineEdits, etc. Echa un vistazo a lo que está disponible, seguramente tendrás otras ideas.

Eso es prácticamente todo lo que necesitamos hacer en Qt Designer. Una última cosa, sin embargo, vamos a cambiar el nombre de todos nuestros elementos con nombres más adecuados, de modo que sea más fácil identificarlos en nuestros archivos de guión:

Image:Qtpropeditor.jpg

Convertir nuestro diálogo a Python

Ahora, vamos a salvar nuestro widget en alguna parte. Se guardará como un archivo .ui, que fácilmente se convertirá en un archivo de guión de Python por medio de pyuic. En Windows, el programa pyuic se ve enriquecido con PyQt (por verificar), en linux es probable que tengas que instalarlo por separado desde tu gestor de paquetes (en sistemas basados en Debian, es parte del paquete de herramientas PyQt4-dev-tools). Para realizar la conversión, tendrás que abrir una ventana de terminal (o una ventana de símbolo de sistema en Windows), ve a donde guardaste el archivo .ui, y escribe: 

pyuic mywidget.ui > mywidget.py

En algunos sistemas el programa se llama pyuic4 en lugar de pyuic. Esta operación simplemente convertirá el archivo .ui en un archivo de guión de Python. Si abrimos el archivo mywidget.py, su contenido es muy fácil de entender: 

from PyQt4 import QtCore, QtGui

class Ui_Dialog(object):
    def setupUi(self, Dialog):
        Dialog.setObjectName("Dialog")
        Dialog.resize(187, 178)
        self.title = QtGui.QLabel(Dialog)
        self.title.setGeometry(QtCore.QRect(10, 10, 271, 16))
        self.title.setObjectName("title")
        self.label_width = QtGui.QLabel(Dialog)
        ...

        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

   def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(QtGui.QApplication.translate("Dialog", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
        self.title.setText(QtGui.QApplication.translate("Dialog", "Plane-O-Matic", None, QtGui.QApplication.UnicodeUTF8))
        ...

Como verás, tiene una estructura muy simple: se crea una clase denominada Ui_Dialog, que almacena los elementos de interfaz de nuestro widget o complemento. Esa clase tiene dos métodos, uno para la configuración del widget, y otro para la traducción de su contenido, eso es parte del mecanismo general de Qt para la traducción de elementos de la interfaz. El método de configuración simplemente crea, uno a uno, los widgets tal como los has definido en Qt Designer, y establece sus opciones, como hayamos decidido con anterioridad. Despues, toda la interfaz se traduce, y por último, se conectan las ranuras (slots) (hablaremos de eso más adelante).

Ahora podemos crear un nuevo widget, y utilizar esta clase para crear su interfaz. Ya podemos ver nuestro widget en acción, poniendo nuestro archivo mywidget.py en un lugar donde FreeCAD lo encuentre (en el directorio bin de FreeCAD, o en cualquiera de los subdirectorios Mod), y, en el intérprete de Python FreeCAD, ejecutamos: 

from PyQt4 import QtGui
import mywidget
d = QtGui.QWidget()
d.ui = mywidget.Ui_Dialog()
d.ui.setupUi(d)
d.show()

¡Y nuestro letrero de diálogo aparecerá! Ten en cuenta que nuestro intérprete de Python todavía está trabajando, ya que hemos usado un letrero de diálogo no modal. Por lo tanto, para cerrarlo, podemos (aparte de hacer clic en el icono de cerrar, por supuesto) escribir: 

d.hide()

Hacer algo con nuestro diálogo

Ahora que podemos mostrar y ocultar nuestro letrero de diálogo, sólo tenemos que añadir una última parte: ¡que haga algo! Si juegas un poco con Qt Designer, descubrirás rápidamente toda una sección llamada "señales y slots". Básicamente, funciona así: los elementos de los widgets o complementos (en la terminología de Qt, estos elementos son a su vez widgets) pueden enviar señales. Estas señales varían según el tipo de widget. Por ejemplo, un botón puede enviar una señal cuando se presiona y cuando es soltado. Estas señales se pueden conectar a los slots, que puede ser una funcionalidad especial de otros widgets (por ejemplo, un cuadro de diálogo tiene un slot "close" (cerrado) en el que se puede conectar la señal de un botón close (de cierre)), o pueden ser funciones de usuario. La Documentación de referencia de PyQt enumera todos los widgets Qt, lo que pueden hacer, que señales pueden enviar, etc.

Lo que haremos aquí, es crear una nueva función que va a formar un plano basado en la altura y anchura, y conectar dicha función a la señal de "pulsado" emitida por nuestro botón "Create!". Empezaremos con la importación de nuestros módulos FreeCAD, poniendo la siguiente línea al comienzo del archivo de guión, donde ya hemos mandado también la importación de QtCore y QtGui: 

import FreeCAD, Part

ahora, añadamos una nueva función a nuestra clase Ui_Dialog: 

def createPlane(self):
    try:
        # first we check if valid numbers have been entered
        w = float(self.width.text())
        h = float(self.height.text())
    except ValueError:
        print "Error! Width and Height values must be valid numbers!"
    else:
        # create a face from 4 points
        p1 = FreeCAD.Vector(0,0,0)
        p2 = FreeCAD.Vector(w,0,0)
        p3 = FreeCAD.Vector(w,h,0)
        p4 = FreeCAD.Vector(0,h,0)
        pointslist = [p1,p2,p3,p4,p1]
        mywire = Part.makePolygon(pointslist)
        myface = Part.Face(mywire)
        Part.show(myface)
        self.hide()

A continuación, tenemos que informar a Qt para que conecte el botón con la función, mediante la colocación de la siguiente línea justo antes de QtCore.QMetaObject.connectSlotsByName(Dialog): 


QtCore.QObject.connect(self.create,QtCore.SIGNAL("pressed()"),self.createPlane)

Como ves, esto conecta la señal pressed() de nuestro objeto create (el Botón "Create!"), a un slot llamado createPlane, que acabamos de definir. Eso es! Ahora, como toque final, podemos añadir una pequeña función para crear el cuadro de diálogo. Así será más fácil hacer las llamadas. Fuera de la clase Ui_Dialog, vamos a añadir este código: 

class plane():
    d = QtGui.QWidget()
    d.ui = Ui_Dialog()
    d.ui.setupUi(d)
    d.show()

A continuación, en FreeCAD, sólo tenemos que hacer: 

import mywidget
mywidget.plane()


Y eso es todo amigos... Ahora puedes probar todo tipo de cosas, como por ejemplo insertar tu widget en la interfaz de FreeCAD (mira la página Pedazos de código), o la creación de herramientas personalizadas mucho más avanzado, mediante el uso de otros elementos en tu widget o complemento.

El archivo de guión completo

Este es el archivo de guión completo, como referencia: 


# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'mywidget.ui'
#
# Created: Mon Jun  1 19:09:10 2009
#      by: PyQt4 UI code generator 4.4.4
#
# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui
import FreeCAD, Part 

class Ui_Dialog(object):
   def setupUi(self, Dialog):
       Dialog.setObjectName("Dialog")
       Dialog.resize(187, 178)
       self.title = QtGui.QLabel(Dialog)
       self.title.setGeometry(QtCore.QRect(10, 10, 271, 16))
       self.title.setObjectName("title")
       self.label_width = QtGui.QLabel(Dialog)
       self.label_width.setGeometry(QtCore.QRect(10, 50, 57, 16))
       self.label_width.setObjectName("label_width")
       self.label_height = QtGui.QLabel(Dialog)
       self.label_height.setGeometry(QtCore.QRect(10, 90, 57, 16))
       self.label_height.setObjectName("label_height")
       self.width = QtGui.QLineEdit(Dialog)
       self.width.setGeometry(QtCore.QRect(60, 40, 111, 26))
       self.width.setObjectName("width")
       self.height = QtGui.QLineEdit(Dialog)
       self.height.setGeometry(QtCore.QRect(60, 80, 111, 26))
       self.height.setObjectName("height")
       self.create = QtGui.QPushButton(Dialog)
       self.create.setGeometry(QtCore.QRect(50, 140, 83, 26))
       self.create.setObjectName("create")

       self.retranslateUi(Dialog)
       QtCore.QObject.connect(self.create,QtCore.SIGNAL("pressed()"),self.createPlane)
       QtCore.QMetaObject.connectSlotsByName(Dialog)

   def retranslateUi(self, Dialog):
       Dialog.setWindowTitle(QtGui.QApplication.translate("Dialog", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
       self.title.setText(QtGui.QApplication.translate("Dialog", "Plane-O-Matic", None, QtGui.QApplication.UnicodeUTF8))
       self.label_width.setText(QtGui.QApplication.translate("Dialog", "Width", None, QtGui.QApplication.UnicodeUTF8))
       self.label_height.setText(QtGui.QApplication.translate("Dialog", "Height", None, QtGui.QApplication.UnicodeUTF8))
       self.create.setText(QtGui.QApplication.translate("Dialog", "Create!", None, QtGui.QApplication.UnicodeUTF8))

   def createPlane(self):
       try:
           # first we check if valid numbers have been entered
           w = float(self.width.text())
           h = float(self.height.text())
       except ValueError:
           print "Error! Width and Height values must be valid numbers!"
       else:
           # create a face from 4 points
           p1 = FreeCAD.Vector(0,0,0)
           p2 = FreeCAD.Vector(w,0,0)
           p3 = FreeCAD.Vector(w,h,0)
           p4 = FreeCAD.Vector(0,h,0)
           pointslist = [p1,p2,p3,p4,p1]
           mywire = Part.makePolygon(pointslist)
           myface = Part.Face(mywire)
           Part.show(myface)

class plane():
    d = QtGui.QWidget()
    d.ui = Ui_Dialog()
    d.ui.setupUi(d)
    d.show()


Traducciones disponibles:

Desarrollando aplicaciones para FreeCAD

Declaración del conservador/mantenedor

Sé que el debate sobre la licencia "adecuada" para el código abierto ocupa una parte importante del ancho de banda de Internet y esa es la razón por la que, en mi opinión, también FreeCAD debería tener aquí algo sobre el tema.

Elegí el LGPL y GPL para el proyecto y conozco los pros y los contras sobre LGPL, de modo que te explicaré algunos motivos para haber tomado esta elección.

FreeCAD es un híbrido entre una biblioteca y una aplicación, de modo que la licencia GPL sería demasiado fuerte para eso. No permitiría escribir módulos comerciales para FreeCAD porque impediría la vinculación con las librerías base de FreeCAD. Te puedes preguntar ¿por qué no prescindir totalmente de los módulos comerciales? En este ámbito Linux es un buen ejemplo. ¿Tendría Linux tanto éxito si la biblioteca GNU de C fuese GPL y, por tanto, incapacitada para ligarse con las aplicaciones no-GPL? Y aunque me encanta la libertad de Linux, yo también quiero ser capaz de usar el magnífico controlador gráfico NVIDIA 3D. Entiendo y acepto que NVIDIA tenga razones para no querer regalar el código de su controlador. Todos trabajamos para empresas y necesitamos el sueldo, o por lo menos comer. Por todo lo anterior, para mí, una coexistencia de software de código abierto y de código cerrado no es algo malo, cuando obedece a las reglas de la LGPL. Me gustaría ver a alguien escribiendo un módulo de importación/exportación de formato Catia para FreeCAD, y que se distribuyese, ya fuera gratis o por dinero. No me gusta obligar a nadie a que ceda más de lo que quiere. Eso no sería bueno ni para él, ni para FreeCAD.

No obstante, esta decisión se ha tomado sólo para el sistema básico de FreeCAD. Todo escritor de un módulo de aplicación puede tomar su propia decisión.


Licencias utilizadas

He aquí las tres licencias bajo las que se publica FreeCAD:

Lesser General Public Licence (LGPL2+)
Para las bibliotecas principales como se indica en los fichero .h y .cpp en src/App, src/Gui, sic/Base, y muchos de los módulos en src/Mod y para el ejecutable como se indica en los archivos .h y .cpp en el directorio src/main. Los iconos y otro material gráfico también son LGPL.
General Public Licence (GPL2+)
Para los archivo de guión de Python que construyen los binarios como se indica en los archivos .py en src/Tools
Open Publication Licence
Para la documentacion en http://free-cad.sourceforge.net/ salvo que se indique lo contrario por su autor

Tratamos de utilizar sólo licencias de tipo LGPL para las bibliotecas vinculadas al núcleo (mira Bibliotecas de terceros), con una excepción:

Mira el archivo debian copyright file de FreeCAD, para tener más detalles sobre las licencias utilizadas en FreeCAD

Alcance de las licencias

Usuarios particulares

Los usuarios particulares pueden utilizar FreeCAD de manera gratuita y pueden hacer básicamente cualquier cosa que quieran hacer con él ....

Usuarios profesionales

Pueden usar libremente FreeCAD para cualquier tipo de trabajo particular o profesional. Se puede personalizar la aplicación como lo deseen. Pueden escribir extensiones para FreeCAD en código abierto o cerrado. Son siempre dueños de sus datos, no están obligados a actualizar FreeCAD, ni cambiar el uso que hacen de FreeCAD. El uso de FreeCAD no les vincula a ningún tipo de contrato u obligación.

Desarrolladores de código abierto (Open Source)

Puede utilizar FreeCAD como base para sus propios módulos de extensión para usos especiales. Pueden elegir entre GPL o LGPL para permitir, o no, el uso de su trabajo en software propietario.

Desarrolladores profesionales

Los desarrolladores profesionales pueden utilizar FreeCAD como base para sus propios módulos de extensión para propósitos especiales y no están obligados a hacer sus módulos en código abierto. Pueden utilizar todos los módulos que utilizan LGPL. Se les permite distribuir FreeCAD junto con su software propietario. Se dará todo el apoyo del autor(es) siempre y cuando exista una actitud de correspondencia recíproca. Si quieres vender tu módulo necesitas una licencia de Coin3d, de lo contrario estás obligado por esta biblioteca a que tu módulo sea de código abierto.

Traducciones disponibles:

Reportando errores

Recientemente, la plataforma de sourceforge hizo la aplicación mantis bug tracker disponible para los proyectos, y FreeCAD ahora la utiliza de forma activa, en lugar del antigua trazador de fallos que tenía incorporado. La dirección de nuestro nuevo gestor de fallos es:

http://sourceforge.net/apps/mantisbt/free-cad/main_page.php

Si piensas que podrías haber encontrado un error, te invitamos a que lo informes allí. Pero antes de informar de un error, por favor, comprueba los elementos siguientes:

  • Asegúrate de que tu error es realmente un bug, es decir, algo que debería estar trabajando y que no está funcionando. Si no estás seguro, no dudes en explicar tu problema en el foro y pregunta qué hacer.
  • Antes de enviar cualquier cosa, lee las FAQ - Preguntas más frecuentes, haz una búsqueda en el foro, y asegúrate de que el mismo error no se ha informado antes, haciendo una búsqueda en el bug tracker.
  • Describe lo más claramente posible el problema, y cómo puede ser reproducido. Si no podemos verificar el error, puede que no seamos capaces de solucionarlo.
  • Incluye la siguiente información: Tu sistema operativo, si es 32 o 64 bits, y la versión de FreeCAD que estás ejecutando.
  • Por favor presenta un informe por separado para cada error.
  • Si estás en un sistema linux y tu error provoca un cuelgue en FreeCAD, puedes intentar ejecutar un backtrace debug: Desde un terminal ejecuta gdb freecad (suponiendo que el paquete gdb esté instalado), entonces, dentro de gdb, escribe run. FreeCAD se ejecutará. Después de que se produzca el fallo, teclea bt, para obtener el trazado completo. Incluye la salida del backtrace en tu informe de error.


Solicitar funcionalidades

Si quieres que aparezca algo en FreeCAD que aún no está implementado, no se trata de un error, sino una solicitud de funcionalidad. También puedes notificarlo en el mismo tracker (lo archivas como una petición de función, en lugar de errores), pero ten en cuenta que no hay garantías de que tus deseos se cumplan.

Envío de parches

En caso de haber programado la corrección de un error, una extensión o algo que puede ser de uso público en FreeCAD, crea un parche con la herramienta Subversion diff y preséntalo en el mismo tracker (lo archivas como parche).



LO SIGUIENTE DE ESTA PÁGINA PARECE SER OBSOLETO, Y NO LO TRADUCIREMOS DE MOMENTO.

The "old" sourceforge tracker (obsolete)

Note: Please use the new mantis bug tracker to submit bugs, this one is now a bit deprecated...

Where to find?

The FreeCAD project has its own tracker summary page. There you find the overview on the individual sections of the tracker.

When to use?

The FreeCAD Bug Tracker

Bugs

If you think you might have found a bug, go to the Bugs Section of the tracker and choose "any" for status to see all bug request ever filed. The keyword search allows you to find bug tracker entries for a similiar issue. If you can not find an older entry about your problem, you should file a new entry on the same page.

Feature Requests

If you are missing a feature in FreeCAD that you think of as beeing absolutely necessary to become the worlds best CAD-Software, you might find the Feature Request section helpfull.

Support Requests

If you don't get around compiling FreeCAD and the Compile On Windows or Compile On Unix section does not give you a hint, or you try to port it to a new environment or are programming new modules or extensions for FreeCAD and need some assistance then the Support Requests section is the place you might want to go to.

New Patches

In case you have programmed a bug fix, an extension or something else that can be of public use in FreeCAD, create a patch using Subversion and file it in the patches section.


Traducciones disponibles:

Este artículo explica paso a paso cómo compilar FreeCAD en Windows.

Pre-requisitos

Lo que necesitas es principalmente el compilador. En Windows utilizamos el compilador M$ VisualStudio 8 (o VC++ Express) con el último service pack. Aunque es probablemente posible utilizar Cygwin o MingW gcc no está comprobado o portado de momento. También lo hemos portado a utilizar VC8 Express Edition. Necesitas descargar el Windows Platform SDK para tener e.g. el Windows.h. También necesitas todas las you need all the Bibliotecas de terceros para compilar FreeCAD satisfactoriamente.

Si utilizar los compiladores de M$ lo más probable es que quieras descargar FreeCAD LibPack que te proporciona todas las bibliotecas necesarias para construir FreeCAD en Windows.

Otros prerequisitos (y programas útiles) son: 

cMake
TortoiseGit
Python 2.6
WiX (Windows installer XML v3.0) - si quieres crear un instalador msi

También es necesario tener, en las rutas de tu sistema, las rutas de: 

Libpack
git (no tortoiseGit, sino git.exe)
python

Construcción con cMake

Antes de nada, tienes que descargar cMake e instalarlo en tu equipo.

El cambio a cMake

Desde la versión 0.9 utilizamos el sistema de construcción cMake para generar los archivos build/make para varios compiladores. No proporcionaremos más archivos .vcproj. Si quieres construir versiones antiguas de FreeCAD (0.8 y anteriores) mira "Construcción de versiones antiguas" más adelante en este artículo.

Hemos cambiado porque se hacía cada vez más desagradable mantener archivos de proyectos para más de 30 tipos de construcción y x compiladores. cMake nos ofrece la posibilidad de soportar IDEs alternativos, como Code::Blocks, Qt Creator y Eclipse CDT el principal compilador que utilizamos sigue siendo M$ VC9 Express. Pero hemos planificado para el futuro un sistema de construcción en Windows sin ningún software de compilación propietario.

Configurar el sistema de construcción

El primer paso para construir FreeCAD con cMake es configurar el entorno. Hay básicamente dos modo de hacerlo:

  • Utilizando LibPack
  • Instalando todas las bibliotecas necesarias y permitiendo a cMake encontrarlas

En el primer caso solo necesitas indicarle a cMake la ruta de LibPack y todo el resto debería estar hecho de forma automática y veras una pantalla como esta: File:CMake_Screen.png

Puedes ver la ruta de LibPack insertada dentro de la variable FREECAD_LIBPACK_DIR'. Empezando desde aquí todo incluidas las rutas están definidas. Solamente necesitas presionar el botón Generate y los archivos del proyecto se generarán.

Si desactivas las opciones FREECAD_LIBPACK_USE, la configuración trata de encontrar cada biblioteca necesaria en tu sistema. Dependiendo de las que las bibliotecas funcionen más o menos bien. De modo que definir frecuentemente algunas rutas a mano. cMake te mostrará lo que no se encuentra y es necesario que sea especificado.

Opciones para el proceso de construcción

El sistema de construcción de cMake nos ofrece mucha más flexibilidad sobre el proceso de construcción. Eso significa que podemos activar y desactivar algunas características o módulos. De un modo similar a la construcción del kernel de Linux. Tienes un montón de conmutadores para determinar el proceso de construcción.

Aquí está la descripción de esos conmutadores. Permitirán principalmente hacer muchos cambios en el futuro porque queremos incrementar la flexibilidad de la construcción mucho más.

Link table
Variable name Descripción Por defecto
FREECAD_LIBPACK_USE Conmuta el uso de FreeCAD LibPack on u off En Win32 on, en otro caso off
FREECAD_LIBPACK_DIR Directorio de LibPack Directorio de código fuente de FreeCAD
FREECAD_BUILD_GUI Construir FreeCAD con todos los módulos relacionados con el interfaz gráfico de usuario Gui ON
FREECAD_BUILD_CAM Construir el módulo de mecanizado CAM, experimental! OFF
FREECAD_BUILD_INSTALLER Crea los archivos de proyecto para el instalador de Windows. OFF
FREECAD_BUILD_DOXYGEN_DOCU Crea los archivos de proyecto para la documentación del código fuente. OFF
FREECAD_MAINTAINERS_BUILD Conmutador necesario solo cuando haces una construcción de versión. OFF

Procedimiento con cMake y Visual Studio 2008

Una vez que inicias el entorno gráfico de usuario de cMake, selecciona el directorio del código fuente, añade el directorio de destino y pulsa en "Configurar". cMake solicitará que selecciones un generador - el recomendado para FreeCAD es "Visual Studio 9 2008".

Después de pulsar en "Siguiente", cMake mostrará errores ya que no puede encontrar LibPack. Tienes que seleccionar manualmente el directorio en el que está Libpack en la variable "FREECAD_LIBPACK_DIR". Después pulsa en "Configurar" otra vez. Una vez termine la configuración, pulsa en "Generar". Ahora has acabado con cMake, y lo puedes cerrar.

Anmtes de utilizar Visual Studio, necesitamos añadir Libpack a las rutas del sistema (sólo tendrás que hacerlo una vez, cuando lo construyas por primera vez). Tienes que ir a "Panel de control >> Sistema>> Configuración avanzada del sistema". En el letrero de diálogo de las "Propiedades del sistema", bajo la pestaña "Avanzadas" está el botón "Variables de entorno". Pulsa sobre el.

Después de pulsar sobre el botón anterior, añade Libpack a las rutas del sistema. Para separarlo de otras rutas usa un ";".

Ahora tienes que iniciar Visual Studio 2008. Visual C++ Express 2008 también funcionará. Antes de construir, es un buen procedimiento copiar el directorio bin de libpack\bin al directorio bin de los archivos de construcción (generados con cMake).

Después ve a "Archivo>> Abrir >> Proyecto/Solución". Necesitas abrir FreeCAD_Trunk.sln, de los archivos de construcción generados con cMake.

Una vez esté abierto, habrá tres menús en la barra de herramientas. Uno de ellos dice "Depurar" - cámbialo a "Release".

Luego ejecuta "Construir>> Construir solución" (o simplemente pulsa F7) - este proceso puede tardar bastante tiempo.

Una vez termine, selecciona "Depurar >> Iniciar sin depuración". Una ventana solicitará que selecciones el archivo exe. Pulsa en el menú bajo "Nombre del archivo ejecutable" y selecciona "Explorar". Tienes que ir al directorio \bin donde están los archivos de código fuente, y seleccionar "FreeCAD.exe"

y ya has terminado!

Construcción desde la línea de comandos

Aquí está un ejemplo de cómo construir FreeCAD desde la línea de comandos: 

rem @echo off
rem   Build script, uses vcbuild to completetly build FreeCAD

rem update trunc
d:
cd "D:\_Projekte\FreeCAD\FreeCAD_0.9"
"C:\Program Files (x86)\Subversion\bin\svn.exe" update 

rem  set the aprobiated Variables here or outside in the system

set PATH=C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem
set INCLUDE=
set LIB=

rem Register VS Build programms
call "C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcvarsall.bat"

rem Set Standard include paths
set INCLUDE=%INCLUDE%;%FrameworkSDKDir%\include
set INCLUDE=%INCLUDE%;C:\Program Files\Microsoft SDKs\Windows\v6.0A\Include

rem Set lib Pathes
set LIB=%LIB%;C:\Program Files\Microsoft SDKs\Windows\v6.0A\Lib
set LIB=%LIB%;%PROGRAMFILES%\Microsoft Visual Studio\VC98\Lib

rem Start the Visuall Studio build process
"C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcpackages\vcbuild.exe" "D:\_Projekte\FreeCAD FreeCAD_0.9_build\FreeCAD_trunk.sln" /useenv

Construcción de versiones antiguas

Utilizando LibPack

Para hacer más sencillo tener FreeCAD compilado, proporcionamos una colección de todas las librerías necesarias. Se llama LibPack. Puedes encontrarlas en la página de descargas en Sourceforge.

Necesitas establecer las siguientes variables de entorno:

FREECADLIB = "D:\Wherever\LIBPACK"
QTDIR = "%FREECADLIB%"

Añadir "%FREECADLIB%\bin" y "%FREECADLIB%\dll" a la variable de sistema PATH. Recuerda que tienes que reemplazar "%FREECADLIB%" con el nombre de la ruta, ya que Windows no reemplaza recursivamente las variables de entorno.

Directorio de setup en Visual Studio

Es necesario definir algunas rutas de búsqueda en Visual Studio. Para cambiarlas, utiliza el menú Tools→Options→Directory

Include

Añade las siguientes rutas de búsqueda a la lista de rutas de búsqueda de include:

  •  %FREECADLIB%\include
  •  %FREECADLIB%\include\Python
  •  %FREECADLIB%\include\boost
  •  %FREECADLIB%\include\xercesc
  •  %FREECADLIB%\include\OpenCascade
  •  %FREECADLIB%\include\OpenCV
  •  %FREECADLIB%\include\Coin
  •  %FREECADLIB%\include\SoQt
  •  %FREECADLIB%\include\QT
  •  %FREECADLIB%\include\QT\Qt3Support
  •  %FREECADLIB%\include\QT\QtCore
  •  %FREECADLIB%\include\QT\QtGui
  •  %FREECADLIB%\include\QT\QtNetwork
  •  %FREECADLIB%\include\QT\QtOpenGL
  •  %FREECADLIB%\include\QT\QtSvg
  •  %FREECADLIB%\include\QT\QtUiTools
  •  %FREECADLIB%\include\QT\QtXml
  •  %FREECADLIB%\include\Gts
  •  %FREECADLIB%\include\zlib
Libs

Añade las siguientes rutas de búsqueda a la lista de rutas de búsqueda de lib:

  •  %FREECADLIB%\lib
Executables

Añade las siguientes rutas de búsqueda a la lista de rutas de búsqueda de executable:

  •  %FREECADLIB%\bin
  • TortoiseSVN directorio de instalación binario, normalmente "C:\Programm Files\TortoiseSVN\bin", este es necesario para una construcción de distribución cuando SubWVRev.exe se utiliza para extraer el número de versión de Subversion.
Necesidades de Python

Durante la compilación se ejecutan algunos archivos de guión en Python. De modo que el interprete de Python tiene que funcionar en el OS. Utiliza un comando para comprobarlo. Si no lo encuentra indicará algo similar a Cannot find python.exe. Si utilizas LibPack también puedes usar python.exe en el directorio bin.

Especial para VC8

Cuando se construye el proyecto con VC8, tienes que cambiar la información vinculada para la librería WildMagic, ya que necesitas una versión diferente para VC6 y VC8. Ambas versiones están suministradas en LIBPACK/dll. En las propiedades del proyecto para AppMesh cambia el nombre de la biblioteca wm.dll a la versión de VC8. Ten cuidado de cambiarla en Debug y configuración de la versión.

Compilación

Después de que ajustes todos los pre-requisitos la compilación está - esperemos - solo a un clic de ratón en VC ;-)

Después de compilar Compiling

Para tener FreeCAD funcionando desde el entorno de compilación necesitas copiar unos cuantos archivos de LibPack al directorio bin donde FreeCAD.exe está instalado después de una construcción satisfactoria:

  • python.exe y python_d.exe de LIBPACK/bin
  • python25.dll y python25_d.dll de LIBPACK/bin
  • python25.zip de LIBPACK/bin
  • Haz una copia de Python25.zip y renombralo a Python25_d.zip
  • QtCore4.dll de LIBPACK/bin
  • QtGui4.dll de LIBPACK/bin
  • boost_signals-vc80-mt-1_34_1.dll de LIBPACK/bin
  • boost_program_options-vc80-mt-1_34_1.dll de LIBPACK/bin
  • xerces-c_2_8.dll de LIBPACK/bin
  • zlib1.dll de LIBPACK/bin
  • coin2.dll de LIBPACK/bin
  • soqt1.dll de LIBPACK/bin
  • QtOpenGL4.dll de LIBPACK/bin
  • QtNetwork4.dll de LIBPACK/bin
  • QtSvg4.dll de LIBPACK/bin
  • QtXml4.dll de LIBPACK/bin

Cuando se utiliza LibPack con una versión de Python anterior a la 2.5 tienes que copiar los siguientes archivos:

  • zlib.pyd y zlib_d.pyd de LIBPACK/bin/lib. Estos se necesitan por Python para abrir la biblioteca de Python comprimida.
  • _sre.pyd y _sre_d.pyd de LIBPACK/bin/lib. Estos se necesitan por Python para la construcción en el sistema de ayuda.

Si no consigues ejecutarlo debido a un error en Python es bastante probable que uno de los archivos zlib*.pyd no se pueda localizar.

Material adicional

Si quieres construir la documentación del código fuente necesitas DoxyGen.

Para crear un paquete de instalación necesitas WIX.


Durante la compilación se ejecutan algunos archivos de guión en Python. De modo que el interprete de Python tiene que funcionar correctamente.

Para obtener más detalles echa un vistazo al README.Linux en tus fuentes.

Antes de nada deberías construir el plugin Qt que proporciona todos los widgets personalizados de FreeCAD que necesitamos para el Qt Designer. Las fuentes se encuentran en 

//src/Tools/plugins/widget//.

De momento no proporcionamos un -- pero ejecutando 

qmake plugin.pro

se crea. Una vez hecho, llamando a make se creará la biblioteca 

//libFreeCAD_widgets.so//.

Para hacer que esta biblioteca sea conocida por Qt Designer tienes que copiar el archivo a 

//$QTDIR/plugin/designer//.
Traducciones disponibles:

En las distribuciones recientes de Linux, FreeCAD es generalmente bastante fácil de construir, ya que todas las dependencias están proporcionadas por el gestor de paquetes. Básicamente, solo tendrás que seguir 3 pasos: 1) Conseguir el código fuente de FreeCAD 2) Instalar las dependencias (paquetes de los que depende FreeCAD) 3) Compilar con "cmake . && make"

Abajo encontrarás explicaciones detalladas del proceso completo y particularidades que podrías encontrar. Si encuentras algún error o algo anticuado (las distribuciones de Linux cambian a menudo) en lo que viene a continuación, por favor ayúdanos corrigiéndolo.

Consiguiendo el código fuente

Antes de que puedas compilar FreeCAD, debes conseguir el código fuente. Hay tres modos de conseguirlo:

Git

El modo más rápido y el mejor de obtener el código es clonar el repositorio de solo lectura de Git (necesitas tener instalado el paquete de git):: 

git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad freecad

Esto situará una copia de la última versión del código fuente de FreeCAD en un nuevo directorio denominado "freecad". La primera vez que intentes conectar al huesped free-cad.git.sourceforge.net, deberías ver un mensaje solicitando la autenticidad de la clave SSH de sourceforge, que es normalmente seguro para aceptar (puedes comprobar sus claves SSH en la web de sorceforge si no estás seguro)

Gihub

Existe un repositorio de FreeCAD en Gihub siempre al día: github.com/FreeCAD/FreeCAD_sf_master

Páquetes de código fuente

Como alternativa, puedes descargar un paquete de código fuente, pero podría ser ya bastante antiguo así que es siempre mejor conseguir el último código fuente desde Git o Subversion. Dependiendo de tu distribución, existen varias formas de conseguir un paquete de código fuente: 

Paquetes de código fuente oficiales de FreeCAD (independientes de la distribución): https://sourceforge.net/projects/free-cad/files/FreeCAD%20Source/
Debian: http://packages.debian.org/source/sid/freecad
Ubuntu: http://packages.ubuntu.com/source/precise/freecad

Consiguiendo las dependencias

Para compilar FreeCAD en Linux primero tienes que instalar todas las bibliotecas mencionadas en Bibliotecas de Terceros. En las distribuciones más recientes esto es generalmente cuestión de instalar algunos paquetes:

Debian y Ubuntu

En los sistemas basados en Debian es bastante sencillo instalar todas las dependencias necesarias. La mayoría de las librerías están disponibles vía apt-get o el gestor de paquetes synaptic. Abajo están listados todos los paquetes que necesitas instalar. Si no utilizas la versión más reciente de tu distribución, algunos de los paquetes de abajo podrían no aparecer en los repositorios. En dicho caso, mira en la sección #Distribuciones antiguas y no convencionales más abajo. 

build-essential
cmake
python
libtool
libcoin60-dev
libsoqt4-dev
libxerces-c-dev
libboost-dev
libboost-filesystem-dev
libboost-regex-dev
libboost-program-options-dev 
libboost-signals-dev
libboost-thread-dev
libqt4-dev
qt4-dev-tools
libqt4-opengl-dev
python-dev
 O:
 libopencascade-dev (versión oficial de Opencascade)
 o:
 liboce*-dev (versión de la comunidad de Opencascade)
 oce-draw
gfortran
libeigen3-dev
libqtwebkit-dev
libode-dev
swig
libzipios++-dev

Opcionalmente también puedes instalar 

libsimage-dev (para que Coin soporte formatos de imágenes adicionales)
checkinstall (para registrar tus archivos instalados en tu gestor de paquetes del sistema, así puedes desinstalarlo después fácilmente)
python-pivy (necesitado por el módulo de Bocetado 2D)
python-qt4 (necesitado por el módulo de Bocetado 2D)
doxygen and libcoin60-doc (si pretendes generar la documentación del código fuente)
libspnav-dev (para soportar dispositivos de 3Dconnexion como Space Navigator o Space Pilot)

Fedora

Necesitas los siguientes paquetes: 

cmake
doxygen
swig
gcc-gfortran
gettext
dos2unix
desktop-file-utils
libXmu-devel
freeimage-devel
mesa-libGLU-devel
OCE-devel
python python-devel
boost-devel
tbb-devel
eigen3-devel
qt-devel
qt-webkit-devel
ode-devel
xerces-c
xerces-c-devel
opencv-devel
smesh-devel
coin2-devel
soqt-devel

Y opcionalmente: 

libspnav-devel (para soportar dispositivos 3Dconnexion como el Space Navigator o Space Pilot)

pivy ( https://bugzilla.redhat.com/show_bug.cgi?id=458975 Pivy no es obligatorio pero si necesario para el módulo de Boceto)

La construcción de FreeCAD con coin3 aún es bastante frustante en Fedora, ya que sólo coin2 se proporciona en los repositorios oficiales, pero si quieres de todos modos, puedes evitar reconstruir todo el conjunto de coin3 / soqt / pivy instalando paquetes preparados para su ejecución de coin3 desde http://www.zultron.com/rpm-repo/

Gentoo

Necesitas los siguientes paquetes para construir FreeCAD: 

dev-cpp/eigen
dev-games/ode
dev-libs/boost
dev-libs/xerces-c
dev-python/pivy
dev-python/PyQt4
media-libs/coin
media-libs/SoQt
sci-libs/opencascade-6.5
sys-libs/zlib
virtual/fortran
x11-libs/qt-gui
x11-libs/qt-opengl
x11-libs/qt-svg
x11-libs/qt-webkit
x11-libs/qt-xmlpatterns
dev-lang/swig-2.0.4-r1
app-admin/eselect-python-20091230
dev-lang/python-2.7.2-r3
dev-util/cmake-2.8.4
sys-apps/findutils-4.4.0

Desde que opencascade no está disponible, podrías compilar también opencascade, para lo cual se necesitas las siguientes librerías: 

media-libs/ftgl
virtual/opengl
x11-libs/libXmu
dev-lang/tcl-8.5.9
dev-lang/tk-8.5.9-r1
dev-tcltk/itcl-3.4_beta1
dev-tcltk/itk-3.4_pre20090417
dev-tcltk/tix-8.4.3
x11-libs/gl2ps
sys-devel/automake-1.11
sys-devel/autoconf-2.68
sys-devel/libtool
dev-java/java-config-2.1.11-r3

OpenSUSE

Necesitas los siguientes paquetes: 

gcc
cmake
OpenCASCADE-devel
libXerces-c-devel
python-devel
libqt4-devel
python-qt4
Coin-devel
SoQt-devel
boost-devel
libode-devel
libQtWebKit-devel
libeigen3-devel
gcc-fortran

Para la versión no estable FreeCAD 0.13 necesitas añadir las bibliotecas Eigen3 y swig, que parece que no están en los repositorios estándar. Puedes conseguirlos aquí: 

Eigen3: http://software.opensuse.org/search?q=eigen3&baseproject=openSUSE%3A12.1&lang=en&exclude_debug=true
swig: http://software.opensuse.org/search?q=swig&baseproject=openSUSE%3A12.1&lang=en&exclude_debug=true

También, observa que la biblioteca Eigen3 de Factory Education causa problemas a veces, así que utiliza la de KDE 4.8 Extra repo

Distribuciones antiguas y no convencionales

En otras distribuciones, tenemos poca información de los usuarios, de modo que podría ser complicado encontrar los paquetes requeridos. Prueba primero localizando las bibliotecas requeridas mencionadas en Bibliotecas de terceros. Ten en cuenta que alguna de ellas podría tener un nombre de paquete ligeramente diferente en tu distribución (como name, libname, name-dev, name-devel, etc...).

También necesitas el [GNU gcc compiler] versión igual o superior a la 3.0.0. g++ también se necesita porque FreeCAD está completamente escrito en C++. Durante la compilación se ejecutan algunos archivos de guión de Python. De modo que el interprete de Python debe funcionar correctamente. Para evitar cualquier tipo de problemas de enlaces durante el proceso de construcción es una buena idea tener las rutas de las bibliotecas en la variable LD_LIBRARY_PATH o en el archivo ld.so.conf. Este es normalmente el caso en las distribuciones recientes.

Para ver más detalles echa un vistazo al README.Linux en tu código fuente.

Abajo hay ayuda adicional para varias bibliotecas que podrían no estar presentes en los repositorios de tu distribición

Eigen 3

La biblioteca Eigen3 es requerida ahora por el módulo del croquizador. Esta biblioteca sólo está disponible a partir de los repositorios de Ubuntu 11.10. Para versiones anteriores de Ubuntu, puedes descargarla desde aquí e instalarla manualmente, o añadir el PPA de construcciones diarias de FreeCAD a tus fuentes de software antes de instalarlo a través de uno de los métodos indicados más abajo.

OpenCASCADE community edition (OCE)

OpenCasCade se ha dividido recientemente en una edición de la comunidad, la cual es mucho, mucho más sencilla de construir. FreeCAD puede utilizar cualquier versión instalada en tu sistema, ya sea la edición "oficial" o la edición de la comunidad. La web de OCE contiene instrucciones detalladas sobre la construcción.

OpenCASCADE versión oficial

Nota: Se recomienda utilizar la edición de la comunidad mencionada arriba, que es más sencilla de construir, pero esta también funciona.

No todas las distribuciones de Linux tienen un paquete oficial de OpenCASCADE en sus repositorios. Tienes que comprobar si existe una disponible para tu distribución. Al menos para Debian Lenny y Ubuntu Intrepid se proporciona un paquete .deb oficial. Para versiones de Debian o Ubuntu más antiguas puedes encontrar paquetes no oficiales aquí. Para construir tu propio paquete .deb privado sigue estos pasos: 

wget http://lyre.mit.edu/~powell/opencascade/opencascade_6.2.0.orig.tar.gz
wget http://lyre.mit.edu/~powell/opencascade/opencascade_6.2.0-7.dsc
wget http://lyre.mit.edu/~powell/opencascade/opencascade_6.2.0-7.diff.gz

dpkg-source -x opencascade_6.2.0-7.dsc

# Install OCC build-deps
sudo apt-get install build-essential devscripts debhelper autoconf
automake libtool bison libx11-dev tcl8.4-dev tk8.4-dev libgl1-mesa-dev
libglu1-mesa-dev java-gcj-compat-dev libxmu-dev

#Build Opencascade packages. This takes hours and requires 
# at least 8 GB of free disk space
cd opencascade-6.2.0 ; debuild

# Install the resulting library debs
sudo dpkg -i libopencascade6.2-0_6.2.0-7_i386.deb
libopencascade6.2-dev_6.2.0-7_i386.deb

Alternativamente, puedes descargar y compilar la última versión desde opencascade.org:

Instala el paquete normalmente, se consciente de que el instalador es un programa en Java que requiere la edición oficial de Java de Sun (nombre de paquete: sun-java6-jre), no la versión de código libre de Java (gij) que está incluida con Ubuntu. Puedes instalarlo si fuera necesario: 

sudo apt-get remove gij
sudo apt-get install sun-java6-jre

Ten cuidado, si estas utilizando gij Java con otras cosas como un plugin de tu navegador, dejarán de funcionar. Si el instalador no funciona, prueba: 

java -cp path_to_file_setup.jar <-Dtemp.dir=path_to_tmp_directory> run

Una vez que el paquete está instalado, ve al directorio "ros" dentro de opencascade, y haz 

./configure --with-tcl=/usr/lib/tcl8.4 --with-tk=/usr/lib/tk8.4

ahora puedes construirlo. Vuelve al directorio ros y haz: 

make

Puede llevar algo de tiempo, incluso algunas horas.

Cuando esté terminado, simplemente instala con 

sudo make install

Los archivos de biblioteca se copiarán a /usr/local/lib donde serán encontrados automáticamente por cualquier programa. Alternativamente, también puedes hacer 

sudo checkinstall

lo cual hará lo mismo que make install pero crea una entrada en tu sistema de gestión de paquetes para que puedas desinstalarlo fácilmente después. Ahora limpia la gran cantidad de archivos temporales de compilación haciendo 

make clean

Posible error 1: Si estas utilizando OCC version 6.2, es probable que el compilador pare justo después de empezar la operación "make". Si sucede esto, edita el archivo "configure", localiza la declaración CXXFLAGS="$CXXFLAGS ", y reemplazala por CXXFLAGS="$CXXFLAGS -ffriend-injection -fpermissive". Luego haz el paso de configure de nuevo.

Posible error 2: Posiblemente varios módulos (WOKSH, WOKLibs, TKWOKTcl, TKViewerTest y TKDraw) indiquen que no pueden encontrar las cabeceras de tcl/tk. En ese caso, ya que la opción no está presente en el archivo configure, tendrás que editar manualmente el makefile de cada uno de estos módulos: Ve a adm/make y en cada uno de los directorios de los módulos con problemas. Edita el Makefile, y localiza las líneas CSF_TclLibs_INCLUDES = -I/usr/include y CSF_TclTkLibs_INCLUDES = -I/usr/include y añade /tcl8.4 y /tk8.4 en ellas de modo que se puedan leer: CSF_TclLibs_INCLUDES = -I/usr/include/tcl8.4 y CSF_TclTkLibs_INCLUDES = -I/usr/include/tk8.4

SoQt

La biblioteca SoQt library debe compilarse contra Qt4, que es el caso de las distribuciones más recientes. Pero en el momento de escribir este artículo solo existían paquetes SoQt4 disponibles para Debian pero no para todas las versiones de Ubuntu. Para construir estos paquetes sigue los siguientes pasos: 

wget http://ftp.de.debian.org/debian/pool/main/s/soqt/soqt_1.4.1.orig.tar.gz
wget http://ftp.de.debian.org/debian/pool/main/s/soqt/soqt_1.4.1-6.dsc
wget http://ftp.de.debian.org/debian/pool/main/s/soqt/soqt_1.4.1-6.diff.gz
dpkg-source -x soqt_1.4.1-6.dsc
sudo apt-get install doxygen devscripts fakeroot debhelper libqt3-mt-dev qt3-dev-tools libqt4-opengl-dev
cd soqt-1.4.1
debuild
sudo dpkg -i libsoqt4-20_1.4.1-6_i386.deb libsoqt4-dev_1.4.1-6_i386.deb libsoqt-dev-common_1.4.1-6_i386.deb

Si estas en un sistema de 64bit system, probablemente tendrás que cambiar i386 por amd64.

Pivy

Pivy no es necesario para construir FreeCAD o para ejecutarlo, pero es necesario para que funcione el módulo de croquizado 2D. Si no vas a utilizar ese módulo, no necesitas pivy. En el momento de escribir este artículo, Pivy aún es muy reciente y podría no estar incluido en los repositorios de tu distribución. Si no puedes encontrar Pivy en los repositorios de paquetes de tu distribución, puedes aprovechar los paquetes de Debian/Ubuntu en la página de descargas de FreeCAD:

http://sourceforge.net/projects/free-cad/files/FreeCAD%20Linux/

o compila pivy tu mismo:

Pivy compilation instructions

Compilar FreeCAD

Utilizando cMake

cMake es un sistema de construcción más moderno que tiene la gran ventaja de ser común para diferentes sistemas (Linux, Windows, MacOSX, etc). FreeCAD utilizas ahora el sistema cMake como su sistema principal de construcciones. La compilación con cMake es normalmente muy simple y se hace en 2 pasos. En el primer paso, cMake comprueba que todos los programas necesarios y bibliotecas están presentes en tu sistema y define todo lo que es necesario para la compilación. Se te darán unas cuantas alternativas detalladas más abajo, pero FreeCAD viene con faltas sensibles. El segundo paso es la compilación en si misma, que produce el ejecutable de FreeCAD.

Ya que FreeCAD es una aplicación pesada, la compilación puede llevar algo de tiempo (unos 10 minutos en un ordenador rápido, 30 minutos en uno lento)

Construcción dentro del código

FreeCAD puede construirse dentro del código, que quiere decir que todos los archivos resultantes de la compilación permanecen en el mismo archivo que el código fuente. Este está bien si simplemente estas ojeando FreeCAD, y quieres eliminarlo fácilmente borrando ese directorio. Pero en caso de que planees compilarlo a menudo, se recomienda realizar una construcción fuera del código fuente, que ofrece algunas ventajas más. Los siguientes comandos compilaran freecad: 

cd freecad (the folder where you cloned the freecad source)
cmake .
make

Tu ejecutable de FreeCAD estará en el directorio "bin", y puedes ejecutarlo con: 

./bin/FreeCAD

Construcción fuera del código

Si pretendes seguir la rápida evolución de FreeCAD, la construcción en un directorio separado es mucho más conveniente. Cada vez que actualices el código fuente, cMake distinguirá de forma inteligente que archivos han cambiado, y recompilará sólo lo que necesita. Las construcciones fuera del código son especialmente útiles utilizando el sistema Git, porque puedes fácilmente probar otras ramas sin confusiones del sistema de construcción. Para construir fuera del código, simplemente crea un directorio de construcción, distinto del de código fuente, y desde el directorio de construcción apunta a cMake hacia el directorio del código fuente: 

mkdir freecad-build
cd freecad-build
cmake ../freecad (o cualquier otra rutaq al directorio de código fuente)
make

Tu ejecutable estará en el directorio "bin".

Opciones de configuración

Hay varios módulos experimentales o sin terminar que podrías construir si quieres trabajar en ellos. Para hacerlo, necesitas establecer las opciones apropiadas para la fase de configuración. Hazlo con la línea de comandos, pasando opciones -D <var>:<type>=<value> a cMake o utilizando uno de los interfaces disponibles (por ejemplo para Debian, los paquetes cmake-qt-gui o cmake-curses-gui).

Como ejemplo, para configurar con la línea de comandos con la construcción del módulo de ensamblajes: 

cmake -D FREECAD_BUILD_ASSEMBLY:BOOL=ON path-to-freecad-root

Las opciones posibles están listadas en el archivo CmakeLists.txt del directorio raíz de FreeCAD.

Utilizando autotools

Autotools está en proceso de ser despreciado en favor de cMake, pero por el momento aún está disponible para construir FreeCAD. Debes tener instalados automake y libtool en tu sistema; en Debian/Ubuntu: 

aptitude install automake libtool

Si obtienes el código fuente con Git o Subversion, entonces el primer paso debe ser 

./autogen.sh

eso crea el archivo de guión de configuración y más. Para el proceso de construcción en si mismo proporcionamos un archivo de guión de configuración. Simplemente escribe 

./configure

Para tener todo configurado. Si quieres un resumen de todas las opciones que puedes especificar, puedes escribir 

./configure --help

Normalmente no necesitaras ninguna de ellas - a menos que tengas una de tus bibliotecas en un directorio realmente nada habitual. Después de terminar la configuración, la compilación de FreeCAD es tan simple como 

make

Si se produce cualquier error durante la construcción a partir del código fuente, por favor comprueba de nuevo esta página y el archivo README.Linux, luego puedes ir al Gestor de incidencias en SourceForge, seleccionaCualquiera para el estado y pulsa el botón del Navegador para ver informes anteriores de problemas de compilación. Después de construir FreeCAD satisfactoriamente, haz 

make install

para instalarlo en tu equipo. El directorio de instalación por defecto es 

~/FreeCAD

Se instalará en un directorio de FreeCAD en tu directorio home, de modo que no necesitas privilegios de administrador. En lugar de make install, también puedes hacer 

checkinstall

En este caso FreeCAD se instalará por tu sistema de gestión de paquetes, así lo puedes desinstalar luego fácilmente. Pero ya que todas las instalaciones de FreeCAD están dentro de un único directorio, simplemente eliminando el directorio de FreeCAD también es un método de desinstalación válido.

Qt designer plugin

Si quieres desarrollar material en Qt para FreeCAD, necesitaras el plugin Qt Designer que proporciona todos los widgets o complementos personalizados de FreeCAD. Ve a 

freecad/src/Tools/plugins/widget

De momento no proporcionamos un makefile -- pero llamando 

qmake plugin.pro

se crea. Una vez hecho esto, llamando 

make

se creará la biblioteca libFreeCAD_widgets.so. Para hacer que esta biblioteca sea conocida por Qt Designer tienes que copiar el archivo a 

$QTDIR/plugin/designer

Doxygen

Si eres suficiente audaz como para bucear entre el código, podrías aprovechar para construir y consultar la Documentación del código de FreeCAD generada por Doxygen

Creación de un paquete para Debian

Si piensas construir un paquete de Debian a partir del código fuente necesitas instalar dichos paquetes antes: 

dh-make
devscripts
lintian (opcional, utilizado para comprobar si los paquetes cumples las normas)

Para construir un paquete abre una consola, y simplemente ve al directorio de FreeCAD y ejecuta 

debuild

Una vez que el paquete se ha construido, puedes utilizar lintian para comprobar si el paquete contiene errores 

lintian your-fresh-new-freecad-package.deb (reemplazar por el nombre del paquete que has creado)

Solución de problemas

Nota para sistemas de 64bit

Cuando se construye FreeCAD para sistemas de 64-bit existe una incidencia con el paquete OpenCASCADE de 64-bit. Para tener FreeCAD funcionando correctamente podrías necesitar ejecutar el archivo ./configure con la definición adicional _OCC64 establecida: 

./configure CXXFLAGS="-D_OCC64"

Para sistemas basados en Debian no es necesario utilizar la solución anterior cuando se utilizan paquetes preconstruidos porque allí el paquete OpenCASCADE está construido para establecer internamente esta definición. Ahora simplemente necesitas compilar FreeCAD del mismo modo que se describe arriba.

Macros Automake

El archivo configure de FreeCAD hace uso de varias macros automake que a veces no se instalan con sus paquetes: bnv_have_qt.m4, coin.m4, y soqt.m4. Si es necesario (error durante la configuración), búscalos en google y los encontrarás fácilmente. Hay algunos archivos de guión simples que necesitas poner en tu directorio /usr/share/aclocal.

Fedora 13

Para construir e instalar FreeCAD en Fedora 13, se necesitan unos cuantos trucos y consejos:

  • Instala los paquetes requeridos, la mayoría están disponibles en los repositorios de Fedora 13
  • Descarga y construye xerces
  • Descarga y construye OpenCascade. Necesitas que apunte a xmu: ./configure --with-xmu-include=/usr/include/X11/Xmu --with-xmu-library=/usr/lib
  • Descarga y construye Pivy. Tienes que eliminar 2 referencias no existentes a "SoQtSpaceball.h" desde pivy/interfaces/soqt.i poniendo las dos líneas como comentarios se permite la construcción e instalación.
  • Configura Freecad. Necesitasa que apunte a varias cosas: ./configure --with-qt4-include=/usr/include --with-qt4-bin=/usr/lib/qt4/bin --with-occ-lib=/usr/local/lib --with-occ-include=/usr/local/inc --with-xercesc-lib=/usr/local/lib
  • make - muestra un problema en el que la construcción se rompe porque la ldflags para soqt está definida como "-LNONE" y hace que libtool lo devuelva. Mi solución fue modificar /usr/lib/Coin2/conf/soqt-default.cfg para que ldflags sea "" en lugar de "-LNONE". Después de esto -> Funciona!
  • make install

Ubuntu Lucid

En Ubuntu Lucid, no necesitas el qtwebkit-dev, ya que se incluye en qt4-dev.

Archivos de guión de construcción automáticos

Aquí está todo lo que necesitas para una construcción completa de FreeCAD. En un único archivo de guión y funciona en las distribuciones más recientes. El comando preguntará por la contraseña del root (para la instalación de los paquetes) y a veces para reconocer algún servidor de repositorios externo o de https-subversion. Este archivo de guión debería ejecutarse en versiones de 32 y 64 bit. Están escritos para distintas versiones, pero seguramente funcionen también en versiones posteriores con algún ligero cambio o tal cual están.

Si tienes un archivo de guión similar para tu distribución preferida, por favor envíanoslo! Lo incorporaremos a este artículo.

Observa que este archivo de guión comienza añadiendo el repositorio PPA de construcción diaria de FreeCAD así se puede proceder con la instalación de la biblioteca Eigen3 (libeigen3-dev). Si ya tienes esta biblioteca instalada en tu sistema, puedes eliminar la primera línea.

Ubuntu 10.04 LTS - Lucid Lynx / Ubuntu 10.10 Maverick Meerkat / Ubuntu 11.04 Natty Narwhal 

sudo add-apt-repository ppa:freecad-maintainers/freecad-daily && sudo apt-get update
sudo apt-get install build-essential python libcoin60-dev libsoqt4-dev \
libxerces-c2-dev libboost-dev libboost-date-time-dev libboost-filesystem-dev \
libboost-graph-dev libboost-iostreams-dev libboost-program-options-dev \
libboost-serialization-dev libboost-signals-dev libboost-regex-dev libboost-thread-dev \
libqt4-dev qt4-dev-tools python2.7-dev libopencascade-dev libsoqt4-dev \
libode-dev subversion cmake libeigen2-dev libsimage-dev python-qt4 \
libtool autotools-dev automake bison flex gfortran libeigen3-dev libqtwebkit-dev git

# checkout the latest source
svn co https://free-cad.svn.sourceforge.net/svnroot/free-cad/trunk freecad

# go to source dir
cd freecad

# build configuration 
cmake .

# build FreeCAD
make

# test FreeCAD
cd bin
./FreeCAD -t 0

# use FreeCAD
./FreeCAD

# Update latest version

# go to source dir
cd freecad

# Update source
svn update

# build configuration 
cmake .

# build FreeCAD
make

OpenSUSE 12.2

No se necesitan repositorios externos para compilar FreeCAD 0.13 con esta versión. Sin embargo, existe una incompatibilidad con python3-devel que es preciso eliminar. FreeCAD puede compilarse desde GIT de forma similar en OpenSUSE 12.2 

# install needed packages for development
sudo zypper install gcc cmake OpenCASCADE-devel libXerces-c-devel \
python-devel libqt4-devel python-qt4 Coin-devel SoQt-devel boost-devel \
libode-devel libQtWebKit-devel libeigen3-devel gcc-fortran git swig

# create new dir, and go into it
mkdir FreeCAD-Compiled 
cd FreeCAD-Compiled

# get the source
git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad

# Now you will have subfolder in this location called free-cad. It contains the source

# make another dir for compilation, and go into it
mkdir FreeCAD-Build1
cd FreeCAD-Build1 

# build configuration 
cmake ../free-cad

# build FreeCAD
make

# test FreeCAD
cd bin
./FreeCAD -t 0

Ya que estas utilizando Git, la próxima vez que quieras compilar no tendrás que clonar todo, simplemente tira desde Git y compila una vez más 

# go into free-cad dir created earlier
cd free-cad

# pull
git pull

# get back to previous dir
cd ..

# Now repeat last few steps from before.

# make another dir for compilation, and go into it
mkdir FreeCAD-Build2
cd FreeCAD-Build2

# build configuration 
cmake ../free-cad

# build FreeCAD
make

# test FreeCAD
cd bin
./FreeCAD -t 0

OpenSUSE 12.1

Para la versión en desarrollo 0.13 de FreeCAD necesitas añadir las bibliotecas Eigen3 y swig, que no parecen estar disponibles en los repositorios estándar. Puedes obtenerlas aquí:

Eigen3: http://software.opensuse.org/search?q=eigen3&baseproject=openSUSE%3A12.1&lang=en&exclude_debug=true

swig: http://software.opensuse.org/search?q=swig&baseproject=openSUSE%3A12.1&lang=en&exclude_debug=true 


# install needed packages for development
sudo zypper install gcc cmake OpenCASCADE-devel libXerces-c-devel \
python-devel libqt4-devel python-qt4 Coin-devel SoQt-devel boost-devel \
libode-devel libQtWebKit-devel libeigen3-devel gcc-fortran git

# create new dir, and go into it
mkdir FreeCAD-Compiled 
cd FreeCAD-Compiled

# get the source
git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad

# Now you will have subfolder in this location called free-cad. It contains the source

# make another dir for compilation, and go into it
mkdir FreeCAD-Build1
cd FreeCAD-Build1 

# build configuration 
cmake ../free-cad

# build FreeCAD
make

# test FreeCAD
cd bin
./FreeCAD -t 0

Ya que estas utilizando Git, la próxima vez que quieras compilar no tendrás que clonar todo, simplemente tira desde Git y compila una vez más 

# go into free-cad dir created earlier
cd free-cad

# pull
git pull

# get back to previous dir
cd ..

# Now repeat last few steps from before.

# make another dir for compilation, and go into it
mkdir FreeCAD-Build2
cd FreeCAD-Build2

# build configuration 
cmake ../free-cad

# build FreeCAD
make

# test FreeCAD
cd bin
./FreeCAD -t 0

make

# test FreeCAD
cd bin
./FreeCAD -t 0

OpenSuse 11.2

Este archivo de guión no funciona de momento porque:

  • libXerces-c-devel parece haber desaparecido.... 
# install needed packages for development
sudo zypper install gcc cmake subversion OpenCASCADE-devel \
libXerces-c-devel python-devel libqt4-devel  python-qt4 \
Coin-devel SoQt-devel boost-devel libode-devel libQtWebKit-devel \
libeigen2-devel gcc-fortran

# get the source
svn co https://free-cad.svn.sourceforge.net/svnroot/free-cad/trunk freecad

# go to source dir
cd freecad

# build configuration 
cmake .

# build FreeCAD
nice make

# test FreeCAD
cd bin
./FreeCAD -t 0

OpenSuse 11.1 

# additional repository (for OpenCascade)
sudo zypper -p http://packman.unixheads.com/suse/11.1/

# install needed packages for development
sudo zypper install gcc cmake subversion OpenCASCADE-devel \
libXerces-c-devel python-devel libqt4-devel  python-qt4 \
Coin-devel SoQt-devel boost-devel libode-devel libQtWebKit-devel \
libeigen2-devel

# get the source
svn co https://free-cad.svn.sourceforge.net/svnroot/free-cad/trunk freecad

# go to source dir
cd freecad

# build configuration 
cmake .

# build FreeCAD
nice make

# test FreeCAD
cd bin
./FreeCAD -t 0

Debian Squeeze 

# get the needed tools and libs
sudo apt-get install build-essential python libcoin60-dev libsoqt4-dev \
libxerces-c2-dev libboost-dev libboost-date-time-dev libboost-filesystem-dev \
libboost-graph-dev libboost-iostreams-dev libboost-program-options-dev \
libboost-serialization-dev libboost-signals-dev libboost-regex-dev \
libqt4-dev qt4-dev-tools python2.5-dev \
libsimage-dev libopencascade-dev \
libsoqt4-dev libode-dev subversion cmake libeigen2-dev python-pivy \
libtool autotools-dev automake gfortran

# checkout the latest source
svn co https://free-cad.svn.sourceforge.net/svnroot/free-cad/trunk freecad

# go to source dir
cd freecad

# build configuration 
cmake .

# build FreeCAD
make

# test FreeCAD
cd bin
./FreeCAD -t 0

Actualizando el código fuente

El desarrollo de FreeCAD sucede rápidamente, cada día se arreglan errores y se agregan nuevas características. El sistema cmake te permite actualizar inteligentemente el código fuente, y sólo recompila lo que ha cambiado, haciendo las siguientes compilaciones realmente rápidas. La actualización del código fuente con Git o Subversion es muy sencilla: 

cd freecad (o donde has clonado el código fuente la primera vez)
git pull (si utilizas Git)

Luego, no necesitas ejecutar cmake de nuevo, simplemente haz: 

cd ../freecad-build (o donde sea tu directorio de construcción)
make
Traducciones disponibles:

Ya que Mac OS X está basado en BSD (UNIX), la compilación de FreeCAD en Mac no es muy diferente a la Compilación en Unix, sin embargo existen algunos detalles específicos para Mac que son críticos para tener todo funcionando correctamente. Estas instrucciones se han probado en Lion (10.7), pero también deberían funcionar en Intel Macs utilizando (Snow) Leopard.

Descargar las fuentes de FreeCAD

Comprueba la última versión del árbol de código fuente de FreeCAD del repositorio de subversion en Sourceforge:

svn co http://free-cad.svn.sourceforge.net/svnroot/free-cad/trunk free-cad

Instalar dependencias

En Mac OS X 10.7, las siguientes dependencias NO están incluidas con el sistema y por tanto deben ser instaladas antes de construir FreeCAD:

  • sip
  • fortran
  • xerces-c
  • boost
  • eigen
  • ftgl
  • coin3d
  • OpenCASCADE
  • Qt
  • pyqt
  • soqt

Opción 1: Homebrew

Nota: Esta sección está en proceso de construcción! Mira en el foro de ayuda para conocer las últimas novedades.

https://sourceforge.net/apps/phpbb/free-cad/viewtopic.php?f=4&t=2064&p=15405

Descarga e instala el gestor de paquetes Homebrew:

http://mxcl.github.com/homebrew/

Luego compila e instala la mayoría de dependencias de FreeCAD: 

brew install sip gfortran xerces-c boost eigen coin qt pyqt soqt ftgl

Ve a CompileOnMac/es#Construir OpenCASCADE.

Opción 2: MacPorts/Fink

Nota: Esta sección necesita actualizarse.

Instala MacPorts, si aún no lo tienes. MacPorts es un sistema que permite descargar, compilar, e instalar muchas aplicaciones de código libre con un simple comando. Aplicaciones similares en el mundo UNIX/Linux son PKGSRC y APT. Para instalar, simplemente descarga la imagen del disco desde la web de MacPorts y sigue las instrucciones:

http://www.macports.org/install.php

Hubieras instalado MacPorts o no, probablemente querrás asegurarte de que está actualizado. Ejecuta: 

sudo port selfupdate

Ahora que MacPorts está instalado y actualizado, puedes comenzar a instalar algunos paquetes requeridos por FreeCAD:

  • xercesc
  • boost
  • py-sip
  • ftlg
  • f2c
  • eigen3
  • py-pyqt4

El comando siguiente compilará/instalará todas las bibliotecas de arriba. Si MacPorts produce errores, puedes tratar de instalarlos uno a uno. 

sudo port install xercesc boost ftgl f2c eigen3 py-sip py-pyqt4

Ten en cuenta que para los paquetes de Python como py-sip y py-pyqt4, existen múltiples paquetes, uno para cada versión de MacPorts de Python.

Ten en cuenta que boost es un paquete bastante grande, y py-pyqt4 depende de qt4-mac, que también es un paquete bastante grande. Puedes querer ejecutar port -v install así tendrás una idea de lo que va sucediendo durante estas construcciones largas.

Instalar un compilador de Fortran

También necesitas un compilador de FORTRAN. El de Apple de gcc en OSX no viene con FORTRAN. Un instalador de GFortran se puede encontrar aquí: http://gcc.gnu.org/wiki/GFortranBinaries#MacOS

Si estas utilizando fink, otro método es utilizar los siguientes comandos (intentado por Shaneyfelt 2100.Nov.14) 

 sudo fink selfupdate
 sudo fink install gcc46

Esto instala otra colección del compilador gcc con el nombre gcc-4 para evitar un conflicto de nombres con el de Apple. Por supuesto esto asume que también tienes fink instalado. Quizá exista un modo más simple?

Los paquete de gcc4x para MacPorts también incluyen compiladores de FORTRAN, así que esto también debería funcionar: 

sudo port install gcc46

Otro paquete posible para MacPorts es g95. Este parece tener un compilador válido para FORTRAN90 y pasará los test de configuración del cmake de FreeCAD, pero la construcción actual parece preguntar por opciones de gcc-specific, así que probablemente se más sencillo pegarlo a gcc4x.

Instalar Eigen3

Descarga y descomprime la última versión de la biblioteca eigen3 aquí: http://eigen.tuxfamily.org/index.php?title=Main_Page Es necesario para la funcionalidad del solucionador. Una vez descomprimido, el directorio denominado 'Eigen' se puede mover dentro de /usr/local/include/eigen3/

Construir OpenCASCADE

Actualmente, el modo más simple de construir OpenCASCADE en OS X es a partir de la (oce). Descarga el código fuente o comprueba el repositorio de Git aquí:

https://github.com/tpaviot/oce

Luego, en un terminal: 

mkdir build
cd build
cmake ..
cd ..
make
make install/strip

Descargar e 'instalar' la plantilla de FreeCAD.app

El siguiente archivo contiene una plantilla empaquetada de la aplicación para FreeCAD. No es estrictamente necesario, pero hace el trabajo con FreeCAD más conveniente que la configuración por defecto de la instalación. La recomendada por la instalación está en el directorio /Applications, pero deberías poder ponerla donde quieras -- simplemente recuerda que el paquete no puede moverse después de que FreeCAD es compilado e instalado (sin algunas modificaciones más). Ejecutando make install utilizando la configuración de abajo se instalará en este paquete.

http://dl.getdropbox.com/u/103808/FreeCAD/FreeCAD_bundle_template_20091128.tar.gz

Compilar

Ahora configurar, compilar, e instalar FreeCAD utilizando los siguientes comandos desde el directorio raíz de FreeCAD. Si pones el paquete FreeCAD.app en un sitio diferente a /Applications (o si no estas utilizando este paquete), cambia el argumento 'PREFIX' en consecuencia. 

./autogen.sh
	
PREFIX=/Applications/FreeCAD.app/Contents

Si instalaste las dependencias según la opción 1 (Homebrew):

Nota: Esta línea de configuración no ha sido verificada y podría contener errores! 

./configure --with-xercesc-lib=/usr/local/lib --with-xercesc-include=/usr/local/include \
--with-boost-lib=/usr/local/lib --with-boost-include=/usr/local/include \
--with-qt4-dir=/usr/local--with-qt4-lib=/usr/local/lib --with-qt4-include=/usr/local/include \
--with-qt4-framework=/usr/local/lib --with-qt4-bin=/usr/local/bin --with-occ-lib=/usr/local/lib \
--with-occ-include=/usr/local/include/oce  --with-coin=/usr/local/lib --with-soqt=/usr/local/lib \
--prefix=/Applications/FreeCAD.app/Contents --bindir=/Applications/FreeCAD.app/Contents/MacOS \
--libdir=/Applications/FreeCAD.app/Contents/Frameworks/FreeCAD \
--includedir=/Applications/FreeCAD.app/Contents/Resources/include \
--datarootdir=/Applications/FreeCAD.app/Contents/Resources/share --enable-debug=no  \
--with-python-include=/System/Library/Frameworks/Python.framework/Versions/2.5/Headers

O si instalaste las dependencias utilizando la opción 2 (MacPorts/Fink): 

./configure --with-xercesc-lib=/opt/local/lib --with-xercesc-include=/opt/local/include \
--with-boost-lib=/opt/local/lib --with-boost-include=/opt/local/include \
--with-qt4-dir=/usr/local/Trolltech/Qt-4.8.0 --with-qt4-lib=/usr/local/Trolltech/Qt-4.8.0/lib \
--with-qt4-include=/usr/local/Trolltech/Qt-4.8.0/include --with-qt4-framework=/Library/Frameworks \
--with-qt4-bin=/usr/local/Trolltech/Qt-4.8.0/bin --with-occ-lib=/usr/local/lib \
--with-occ-include=/usr/local/include/oce  --with-coin=/Library/Frameworks \
--with-soqt=/Library/Frameworks --prefix=/Applications/FreeCAD.app/Contents \
--bindir=/Applications/FreeCAD.app/Contents/MacOS --libdir=/Applications/FreeCAD.app/Contents/Frameworks/FreeCAD \
--includedir=/Applications/FreeCAD.app/Contents/Resources/include \
--datarootdir=/Applications/FreeCAD.app/Contents/Resources/share --enable-debug=no  \
--with-python-include=/System/Library/Frameworks/Python.framework/Versions/2.5/Headers

Luego: 

make
make install

Dependiendo de tu equipo, el paso de make puede tardar bastante.

Ejecutar

Si todo ha ido correctamente, doble clic en el paquete .app debería iniciar FreeCAD. Si tienes algún inconveniente, escribe los detalles en el foro de ayuda.

PyQt4

Algunos usuarios han informado de un mensaje de error indicando "No hay ningún módulo llamado PyQt4" en el inicio de FreeCAD. Este es un método para corregirlo: 

cd /Library/Python/2.6/site-packages
sudo ln -s /contrib/lib/python2.6/site-packages/PyQt4 .
sudo ln -s /contrib/lib/python2.6/site-packages/sip* .
cd /volatile/FreeCAD-r5443-ser/bin/pivy
cp _coin.dylib _coin.so
cd /volatile/FreeCAD-r5443-ser/lib
for i in *.dylib; do j=`basename $i .dylib`; cp $i $j.so; done

Pivy

Algunos componentes de FreeCAD no funcionarán sin Pivy. Mira aquí para ver instrucciones parciales de instalación.

Traducciones disponibles:

Resumen

Estas son bibliotecas que no se han cambiado en el proyecto de FreeCAD. Son utilizadas básicamente sin cambios como bibliotecas de vínculos dinámicos (*.so o *.dll). Si se necesita un cambio o una clase que las envuelva, entonces el código del envoltorio o la biblioteca modificada tienen que moverse al paquete base de FreeCAD. Las bibliotecas utilizadas son:

Considera el uso de LibPack en lugar de descargar e instalar todo por tu cuenta.

Enlaces

Tabla de enlaces
Nombre biblioteca Versión necesitada Enlace para conseguirla
Python >= 2.5.x http://www.python.org/
OpenCasCade >= 5.2 http://www.opencascade.org
Qt >= 4.1.x http://www.qtsoftware.com
Coin3D >= 2.x http://www.coin3d.org
ODE >= 0.10.x http://www.ode.org
SoQt >= 1.2 http://www.coin3d.org
Xerces-C++ >= 2.7.x < 3.0 http://xml.apache.org/xerces-c/
GTS >= 0.7.x http://gts.sourceforge.net/
Zlib >= 1.x.x http://www.zlib.net/
Boost >= 1.33.x http://www.boost.org/
Eigen3 >= 3.0.1 http://eigen.tuxfamily.org/index.php?title=Main_Page

Detalles

Python

Versión: 2.5 o superior

Licencia: Python 2.5 licencia

Puedes utilizar el código fuente o los binarios de http://www.python.org/ o utilizar alternativamente ActiveState Python de http://www.activestate.com/ aunque es algo difícil conseguir las bibliotecas depuradas de ActiveState.

Descripción

Python es el principal lenguaje de escritura y es utilizado a través de la aplicación. Por ejemplo:

  • Implementar archivos de guión para hacer pruebas sobre:
    • perdidas de memoria
    • asegurar la presencia de funcionalidad después de hacer cambios
    • comprobaciones tras la construcción
    • comprobar la cobertura de las pruebas
  • Macros y grabación de macros
  • Implementar la lógica de la aplicación para paquetes estándar
  • Implementación de entornos completos
  • Carga dinámica de paquetes
  • Implementación de reglas para el diseño (ingeniería del conocimiento)
  • Haciendo algo en Internet como grupos de trabajo y PDM
  • Y más ...

Especialmente la carga dinámica de paquetes de Python se utiliza para cargar en tiempo de ejecución funcionalidades adicionales y entornos necesitados para las tareas. Para una visión más detallada mira: www.python.org Por qué Python? podrías preguntar. Existen varias razones: He utilizado diferentes lenguajes en mi vida profesional:

  • Perl
  • Tcl/Tk
  • VB
  • Java

Python está más orientado a objetos que Perl y Tcl, el código no está tan liado como en Perl y VB. Java no es un lenguaje de escritura en primer lugar y difícil (o imposible) de embeber. Python está bien documentado y extendido. Está también bien comprobado y tiene un fuerte soporte en la comunidad de software libre.

Créditos

Van para Guido van Rossum y un montón de gente que hace de Python un éxito!

OpenCasCade

Versión: 5.2 o superior

Licencia: OCTPL

OCC es un kernel de CAD completo. Originalmente, fue desarrollado por Matra Datavision en Francia para las aplicaciones Strim y Euclid Quantum y después lo pasaron a código libre. Es una enorme biblioteca y hace que sea posible una aplicación de CAD libre en primer lugar, proporcionando algunos paquetes que serían complicados o imposibles de implementar en un proyecto de código libre:

  • Un kernel de geometría que admite STEP
  • Un modelo topológico de datos y todas las funciones necesarias para trabajar con (cortar, fusionar, extruir, etc.)
  • Procesadores estándar de importación / Exportación como STEP, IGES, VRML
  • Visores 3D y 2D con soporte para la selección
  • Un documento y estructura de datos de proyecto con soporte para guardar y restaurar, vinculación externa de documentos, recalculo del historial de diseño (modelado paramétrico) y una facilidad de cargar nuevos tipos de datos como un paquete de extensión dinámicamente

Para conocer más sobre OpenCasCade echa un vistazo a la página de OpenCasCade o http://www.opencascade.org.

Qt

Versión: 4.1.x o superior

Licencia: GPL v2.0/v3.0 o Comercial (desde la versión 4.5 también en LPGL v2.1)

No creo que necesite decir mucho sobre Qt. Es uno de las utilidades para interfaces gráficas de usuario GUI más utilizadas en los proyectos de código libre. Para mi el punto más importante para utilizar Qt es Qt Designer y la posibilidad de cargar letreros de diálogo completos como recursos (XML) e incorporar complementos (widgets) especializados. En una aplicación de CAX la interacción con el usuario y los letreros de diálogo son de lejos la parte más importante del código y un buen diseñador de letreros de diálogo es muy importante para extender FreeCAD fácilmente con nuevas funcionalidades. Puedes encontrar información complementaria y una muy buena documentación de ayuda en línea en http://www.qtsoftware.com.

Coin3D

Versión: 2.0 o superior

Licencia: GPL v2.0 o Comercial

Coin es una biblioteca de gráficos 3D de alto nivel con una interfaz de programación para aplicaciones en C++. Coin utiliza estructuras de datos de la escena gráfica para renderizar gráficos en tiempo real adecuados para la mayoría de aplicaciones de visualización para ingeniería y científicos.

Coin es portable sobre un amplio rango de plataformas: Cualquier plataforma UNIX / Linux / *BSD, todos los sistemas operativos de Microsoft Windows, y Mac OS X.

Coin está construido sobre el estándar de la industria OpenGL bibloteca de modo de renderizado inmediato, y añade abstracción para primitivas de nivel superior, proporciona interactividad 3D, aumenta enormemente la conveniencia y productividad de los programadores, y contiene muchas características de optimización complejas para un renderizado rápido que son transparentes para el programador de la aplicación.

Coin está basado en el SGI de la API de Open Inventor. Open Inventor, para aquellos que no están familiarizados con él, hace tiempo que se ha convertido en el estándar de las bibliotecas gráficas para software de visualización y simulación en la comunidad de ingeniería y científica. Se ha probado sobre un periodo de más de 10 años, su madurez contribuye a su éxito como un bloque de construcción principal en miles de aplicaciones de ingeniería de larga escala alrededor del mundo.

Utilizaremos OpenInventor como visor 3D porque el visor de OpenCasCade (AIS y Graphics3D) tiene serias limitaciones cuellos de botella de rendimiento, especialmente cuando se trata de renderizado de ingeniería de larga escala. Otras cosas como texturas o renderizado volumétrico no están soportados realmente, etc.

Desde la versión 2.0 Coin utiliza un modelo de licencia diferente. Ya no es LGPL. Utilizan GPL para el código libre y licencias comerciales para aplicaciones de código cerrado. Eso significa que si quieres vender tu trabajo basado en FreeCAD (módulos de extensión) tienes que comprar una licencia de Coin!

ODE (Open dynamic engine)

Versión: 0.10.0 o superior

Licencia: LGPL v2.1 o superiores o BSD

ODE una biblioteca de código libre, de alto rendimiento para la simulación de dinámica de cuerpos rígidos. Está lleno de características, estable, maduro e independiente de la plataforma con una API C/C++ sencilla de utilizar. Tiene tipos de unión avanzados e detección de colisiones integrada con fricción. ODE para simulación de vehículos, objetos en entornos virtuales y criaturas virtuales. Es utilizado actualmente en muchos juegos de ordenador, herramientas de autor 3D y herramientas de simulación.

Créditos

Russell Smith es el principal autor de ODE.


SoQt

Versión: 1.2.0 o superior

Licencia: GPL v2.0 o Comercial

SoQt es la cubierta de Inventor para Qt Gui Toolkit. Por desgracia, ya no es LGPL así que tenemos que eliminarlo del código base de FreeCAD y vincularlo como una biblioteca. Tiene el mismo modelo de licencia que Coin. Y tienes que compilarlo con tu versión de Qt.

Xerces-C++

Versión: 2.7.0 o superior

Licencia: Apache Software License Versión 2.0

Xerces-C++ es un analizador de validación XML escrito en C++. Xerces-C++ hace sencillo darle a tu aplicación la capacidad de leer y escribir datos XML. Una biblioteca compartida se proprciona para analizar, generar, manipular, y validar documentos XML.

Xerces-C++ es fiel a la recomendación de XML 1.0 y muchos estándares asociados (mira las características abajo).

El analizador proporciona alto rendimiento, modularidad, y escalabilidad. El código fuente, los ejemplos y la documentación de la API se proporcionan con el analizador. Para la portabilidad, se ha tenido cuidado de hacer un mínimo uso de plantillas, no RTTI, y un mínimo uso de #ifdefs.

El analizador es utilizado para guardar y restaurar parámetros en FreeCAD.

GTS

Versión: 0.7.x

Licencia: LGPL v2.0 o superior

GTS se mantiene para la biblioteca de superficies trianguladas GNU. Es una biblioteca de código libre que pretende proporcionar un conjunto de funciones útiles para trabajar con superficies 3D malladas con triángulos interconectados. El código fuente está disponible gratuitamente bajo la licencia LGPL.

Normalmente nio es necesario para compilar FreeCAD. Puedes conmutar la utilización con un preprocesador en FCConfig.h.

Zlib

Versión: 1.x.x

Licencia: zlib

zlib está diseñado para ser libre, de propósito general, legalmente sin estorbos, eso es, no está cubierto por ningún tipo de patentes. Es una biblioteca de compresión de datos con mínimas perdidas para utilizarse en virtualmente cualquier hardware y sistema operativo. El formato de datos zlib es portable a través de las plataformas. A diferencia del método de compresión utilizada en la compresión de Unix y en el formato de imágenes GIF, el método de compresión utilizado en zlib esencialmente nunca expande los datos. (LZW puede duplicar o triplicar el tamaño del archivo en casos extremos.) La huella de memoria de zlib también es independiente de las entradas de datos y se puede reducir, si es necesario, con algunas perdidas en la compresión.


Boost

Versión: 1.33.x

Licencia: Boost Software License - Versión 1.0

Las bibliotecas C++ Boost son una colección de evaluación de pares, bibliotecas de código libre que extienden la funcionalidad de C++. Las bibliotecas se licencian bajo la licencia de software de Boost, diseñada para permitir que Boost sea utilizado con proyectos de código abierto o cerrado. Muchos de los fundadores de Boost están en el comité del estándar C++ y diversas bibliotecas de Boost han sido aceptadas para incorporarse al informe técnico 1 de C++0x.

Las bibliotecas apuntan a un amplio rango de usuarios y dominios de aplicaciones C++. Desde bibliotecas de propósito general como SmartPtr, a abstracciones de OS como FileSystem, para bibliotecas principalmente apuntando a otros desarrolladores de bibliotecas y usuarios avanzados de C++, como MPL.

En orden de asegurar la eficiencia y flexibilidad, Boost hace un uso extensivo de las plantillas. Boost ha sido una fuente de trabajo extensivo e investigación en programación general y meta-programación en C++.

Mira: http://www.boost.org/ para más detalles.

LibPack

LibPack es un paquete conveniente con todas las bibliotecas de arriba empaquetadas juntas. Está disponible actualmente para la plataforma Windows en la página de Descargas! Si trabajas en Linux no necesitas LibPack, en su lugar asegúrate de utilizar los repositorios de paquetes de tu distribución Linux.

FreeCADLibs7.x Registro de cambios

  • Utilizando QT 4.5.x y Coin 3.1.x
  • Biblioteca de plantilla Eigen añadida para Robot
  • SMESH experimental


Traducciones disponibles:

Página de herramientas

Para cualquier desarrollo de software serio necesitas herramientas. Aquí está una lista de las herramientas que utilizamos para desarrollar FreeCAD:

Herramientas independientes de la plataforma

Qt-Toolkit

Qt-toolkit es una avanzada herramienta de diseño de interfaces de usuario independiente de la plataforma. Está contenida en LibPack de FreeCAD, pero también puede descargarse en Qt project.

InkScape

Gran programa de diseño vectorial. Se utiliza para dibujar iconos e imágenes SVG. Descargalo en www.inkscape.org.

Doxygen

Una herramienta muy buena y estable para generar documentación del codigo a partir de los archivos .h y .cpp.

Gimp

No hay mucho que decir sobre el programa de manipulación de imágenes de GNU. Además de que puede manejar archivos .xpm que es un modo muy conveniente de manejar iconos en los programas de QT. XPM es básicamente código en C que puede compilarse en un programa.

Consigue GIMP aquí: www.gimp.org

Herramientas en Windows

Visual Studio 8 Express

Aunque VC8 es para desarrollos en C++ no ha avanzado mucho desde VisualStudio 6 (en mi opinión ha sido un gran paso atrás), es un sistema de desarrollo libre en Windows. Para aplicaciones nativas Win32 necesitas descargar la PlatformSDK de M$.

Así que la Express edition es difícil de encontrar. Pero podrías probar este enlace

CamStudio

Es una herramienta de código libre para grabar Screencasts (Webcasts). Es una herramienta muy buena para crear tutoriales grabándolos. No es tan aburrido como escribir documentación.

Mira camstudio.org para más detalles.


Tortoise SVN

Esta es una gran herramienta. Hace que el uso de Subversion (nuestro sistema de control de versiones en sf.net) sea un auténtico placer. Puedes a través de la integración con el explorador, manejar revisiones de forma sencilla, comprobar diferencias, resolver conflictos, crear ramas, etc. El letrero de diálogo de asignación es una pieza de arte. Te da un resumen de los archivos modificados y te permite enviarlos o no. Esto hace sencillo empaquetar los cambios en unidades lógicas y ofrece un mensaje de envío claro.

Encontrarás ToroiseSVN en tortoisesvn.tigris.org.

StarUML

Un programa UML de código libre lleno de características. Tiene un montón de características de las grandes, incluyendo ingeniería inversa del código fuente C++....

Descargalo aquí: staruml.sourceforge.net


Herramientas en Linux

PENDIENTE

Traducciones disponibles:

Esta página muestra las diferentes formas de iniciar FreeCAD y las características de configuración más importantes.

Iniciando FreeCAD desde la línea de comandos

FreeCAD puede iniciarse normalmente, haciendo doble clic en el icono del escritorio o seleccionándolo en el menú de inicio, pero también sr puede iniciar directamente desde la línea de comandos. Esto te permite cambiar algunos de las opciones por defecto de inicio.

Opciones de la línea de comandos

Las opciones de la línea de comandos están sujetas a frecuentes cambios, por tanto es una buena idea comprobar las opciones actuales escribiendo: 

FreeCAD --help

En la respuesta puedes leer los posibles parámetros: 

Usage:
FreeCAD [options] File1 File2 .....
Allowed options:  

Generic options:
 -v [ --version ]      print version string
 -h [ --help ]         print help message
 -c [ --console ]      start in console mode

Configuration:
 -l [ --write-log ] arg    write a log file
 -t [ --run-test ] arg     test level
 -M [ --module-path ] arg  additional module paths
 -P [ --python-path ] arg  additional python paths
 --response-file arg       can be specified with '@name', too

Respuesta y archivos de configuración

FreeCAD puede leer algunas de estas opciones de un archivo de configuración. Este archivo debe estar en el directorio bin y debe llamarse FreeCAD.cfg. Ten en cuenta que las opciones que especifiques en la línea de comando sobrescriben el archivo de configuración!

Algunos sistemas operativos tienen límites de longitud muy bajos para la línea de comandos. El modo más habitual de evitar esas limitaciones es utilizar un archivo de respuesta. Un archivo de respuesta es simplemente un archivo de configuración que utiliza la misma sintaxis que la línea de comandos. Si la línea de comandos especifica un nombre de archivo de respuesta a utilizar, es cargado y analizado sintáticamente en adición a la línea de comandos: 

FreeCAD @ResponseFile.txt

o: 

FreeCAD --response-file=ResponseFile.txt

Opciones ocultas

Existen varias opciones no visibles por el usuario. Estas opciones son por ejemplo los parámetros de X-Window analizados por el sistema Windows:

  • -display display, establece la visualización de X (por defecto es $DISPLAY).
  • -geometry geometry, establece la geometría cliente de la primera ventana que es mostrada.
  • -fn or -font font, Define la fuente de letra de la aplicación. La fuente de letra debería estar especificada utilizando una descripción de fuente lógica de X.
  • -bg or -background color, establece el color de fondo por defectoy una paleta para la aplicación (se calculan las sombras iluminadas y oscuras).
  • -fg or -foreground color, establece el color de primer planor.
  • -btn or -button color, establece el color por defecto de los botones.
  • -name name, establece el nombre de la aplicación.
  • -title title, establece el título de la aplicación.
  • -visual TrueColor, fuerza a la aplicación a utilizar la visualización TrueColor en una visualización de 8-bit.
  • -ncols count, limita el número de colores asignados en el cubo de color de visualización de 8-bit, si la aplicación está utilizando la especificación del color QApplication::ManyColor. Si el computo es 216 entonces se utiliza un cubo de color de 6x6x6 (por ejemplo 6 niveles de rojo, 6 de verde y 6 de azul); para otros valores, se utiliza un cubo aproximadamente proporcional a un cubo de 2x3x1.
  • -cmap, cause que la aplicación instale un mapa de color privado en una visualización de 8-bit.


Ejecución de FreeCAD sin interfaz de usuario

FreeCAD normalmente se inicia en el modo de interfaz de usuario gráfico GUI, pero puedes forzar que inicie en modo consola escribiendo: 

FreeCAD -c

desde la línea de comandos. En el modo consola, no se mostrará el interfaz de usuario, y tendrás presente la consola del interprete de Python. Desde ella tienes la misma funcionalidad que desde el interprete de Python que se ejecuta dentro del interfaz de usuario gráfico GUI de FreeCAD, y acceso normal a todos los módulos y plugins de FreeCAD, exceptuando el módulo FreeCADGui. Ten en cuenta que los módulos que dependan del FreeCADGui podrían tampoco estar disponibles.


Ejecución de FreeCAD como un módulo de Python

FreeCAD también puede utilizarse para ejecutar como un módulo de Python dentro de otras aplicaciones que utilizan Python o desde un interprete de Python externo. Para ello, la aplicación anfitriona de Python debe saber donde están las librerías de FreeCAD. El mejor modo para obtener eso es añadir temporalmente las librerías de FreeCAD a la variable sys.path. El código siguiente escrito desde un interprete de Python importará FreeCAD y te permitirá ejecutarlo del mismo modo que en el modo consola:

import sys sys.path.append("path/to/FreeCAD/lib") # change this by your own FreeCAD lib path import FreeCAD

Una vez que FreeCAD está cargado, puedes interactuar con tu aplicación anfitriona de cualquier modo que puedas imaginar!

El conjunto de configuración

En cada inicio FreeCAD examina sus alrededores y los parámetros de la línea de comandos. Esto construye un conjunto de configuración que guarda la esencia de toda la información de la ejecución. Esta información es después utilizada para determinar la ubicación donde guardar los datos del usuario o archivos de registro. También es muy importante para los análisis postmortem. Por lo tanto es guardado en el archivo de registro.

Información relativa al usuario

Entradas de configuración de usuario
Nombre variable configuración Sinopsis Ejemplo M$ Ejemplo Posix (Linux)
UserAppData Ruta donde FreeCAD almacena los datos de la aplicación relativos al usuario. C:\Documents and Settings\username\Application Data\FreeCAD /home/username/.FreeCAD
UserParameter Archivo donde FreeCAD almacena los datos de la aplicación relativos al usuario. C:\Documents and Settings\username\Application Data\FreeCAD\user.cfg /home/username/.FreeCAD/user.cfg
SystemParameter Archivo donde FreeCAD almacena datos relativos a la aplicación. C:\Documents and Settings\username\Application Data\FreeCAD\system.cfg /home/username/.FreeCAD/system.cfg
UserHomePath Ruta de la carpeta de inicio del usuario actual C:\Documents and Settings\username\My Documents /home/username

Argumentos de la línea de comando

Entradas de configuración de usuario
Nombre variable configuración Sinopsis Ejemplo
LoggingFile 1 si el logging está activado 1
LoggingFileName Nombre de archivo en el que está ubicado el registro C:\Documents and Settings\username\Application Data\FreeCAD\FreeCAD.log
RunMode Esto indica como funcionará el bucle principal. "Script" significa que el archivo de guión dado se llamará y luego se saldrá. "Cmd" ejecuta el interprete de la línea de comandos. "Internal" ejecuta un archivo de guión interno. "Gui" introduce el bucle de eventos de la interfaz de usuario gráfica GUI. "Module" carga un módulo de Python dado. "Cmd"
FileName Su significado depende del modo de ejecución
ScriptFileName Su significado depende del modo de ejecución
Verbose Nivel de verborrea de FreeCAD "" o "strict"
OpenFileCount Mantiene el número de archivos abiertos a través de argumentos de la línea de comandos "12"
AdditionalModulePathsMantiene las rutas de módulos adicionales dados en la línea de comandos "extraModules/"

Relativos al sistema

Entradas de configuración de usuario
Nombre variable configuración Sinopsis Ejemplo M$ Ejemplo Posix (Linux)
AppHomePath c:/Progam Files/FreeCAD_0.7 /user/local/FreeCAD_0.7
PythonSearchPath Mantiene una lista de las rutas en las cuales Python busca módulos. Esto es al inicio se puede cambiar durante la ejecución

Algunas bibliotecas necesitan llamar a variables de entorno del sistema. A veces cuando existe un problema con una instalación de FreeCAD, es porque algunas variables de entorno no están o se han definido mal. Por tanto, algunas variables importantes son duplicadas en la Configuración y guardadas en el archivo de registro.

Variables de entorno relativas a Python:

  • PYTHONPATH
  • PYTHONHOME
  • TCL_LIBRARY
  • TCLLIBPATH

Variables de entorno relativas a OpenCascade:

  • CSF_MDTVFontDirectory
  • CSF_MDTVTexturesDirectory
  • CSF_UnitsDefinition
  • CSF_UnitsLexicon
  • CSF_StandardDefaults
  • CSF_PluginDefaults
  • CSF_LANGUAGE
  • CSF_SHMessage
  • CSF_XCAFDefaults
  • CSF_GraphicShr
  • CSF_IGESDefaults
  • CSF_STEPDefaults

Variables de entorno relativas al sistema:

  • PATH

Información relativa a la construcción

La tabla de abajo muestra la información disponible sobre la versión de construcción. La mayoría proviene del repositorio de Subversion. Esto es necesario para reconstruir exactamente una versión!

Entradas de configuración de usuario
Nombre variable configuración Sinopsis Ejemplo
BuildVersionMajor Número de versión principal de la construcción. Definida en src/Build/Version.h.in 0
BuildVersionMinor Número de versión secundario de la construcción. Definida en src/Build/Version.h.in 7
BuildRevision Número de revisión del repositorio SVN del src en la construcción. Generado por SVN 356
BuildRevisionRange Rango de diferentes cambios 123-356
BuildRepositoryURL URL del repositorio https://free-cad.svn.sourceforge.net/svnroot/free-cad/trunk/src
BuildRevisionDate Fecha de la revisión de arriba 2007/02/03 22:21:18
BuildScrClean Indica si el código fuente fue modificado después de su descarga Src modified
BuildScrMixed Src not mixed

Relativos al marcado

Estas entradas de configuración son relativas al mecanismo de marcado de FreeCAD. Mira Marcado para más detalles.

Entradas de configuración de usuario
Nombre variable configuración Sinopsis Ejemplo
ExeName Nombre del archivo ejecutable de la construcción. Puede diferir de la de FreeCAD si es utilizado un main.cpp diferente. FreeCAD.exe
ExeVersion Versión global mostrada al inicio V0.7
AppIcon Icono que es utilizado por el ejecutable, mostrado en Application MainWindow. "FCIcon"
ConsoleBanner Banner que es mostrado en modo consola
SplashPicture Nombre del icono utilizado por la pantalla de bienvenida "FreeCADSplasher"
SplashAlignment Alineación del texto en el letrero de diálogo de bienvenida Left"
SplashTextColor Color del texto de bienvenida "#000000"
StartWorkbench Nombre del entorno que comenzará automáticamente después del inicio "Part design"
HiddenDockWindow Lista de dockwindows (separadas por un punto y coma) que serán mostradas "Property editor"
Traducciones disponibles:
Build Support Tools/es

La Utilidad de construcción de FreeCAD (FreeCAD build tool o fcbt) es un archivo de guión en Python ubicado en 

trunc/src/Tools/fcbt.py

Se puede utilizar para simplificar algunas tareas frecuentes de construcción, distribución y extensión de FreeCAD.

Utilización

Con Python correctamente instalado, fcbt se puede invocar por el comando 

python fbct.py

Muestra un menú, donde puedes seleccionar la tarea para el que lo quieres utilizar: 

FreeCAD Build Tool
 Usage:
    fcbt <command name> [command parameter]
 possible commands are:
  - DistSrc         (DS)   Build a source Distr. of the current source tree
  - DistBin         (DB)   Build a binary Distr. of the current source tree
  - DistSetup       (DI)   Build a Setup Distr. of the current source tree
  - DistSetup       (DUI)  Build a User Setup Distr. of the current source tree
  - DistAll         (DA)   Run all three above modules
  - NextBuildNumber (NBN)  Increase the Build Number of this Version
  - CreateModule    (CM)   Insert a new FreeCAD Module in the module directory

 For help on the modules type:
   fcbt <command name> ?

Introduce el nombre abreviado del comando que quieres utilizar. Por ejemplo escribe "CM" para crear un módulo.

DistSrc

El comando "DS" crea un distribución de código fuente del árbol de código fuente actual.

DistBin

El comando "DB" crea una distribución binaria del árbol de código fuente actual.

DistSetup

El comando "DI" crea una distribución de setup del árbol de código fuente actual.

DistSetup

El comando "DUI" crea una distribución de setup de usuario del árbol de código fuente actual.

DistAll

El comando "DA" executes "DS", "DB" y "DI" en secuencia.

NextBuildNumber

El comando "NBN" incrementa el número de la construcción para crear una nueva versión de FreeCAD.

CreateModule

El comando "CM" crea un nuevo módulo de aplicación.

Traducciones disponibles:

La adición de nuevos módulos y entornos en FreeCAD es muy sencillo. Denominamos módulo a cualquier extensión de FreeCAD, mientras que entorno es una configuración especial de interfaz gráfica de usuario que agrupa algunas barras de herramientas y menús. Normalmente creas un nuevo módulo que contiene su propio entorno.

Los módulos se pueden programar en C++ o en Python, o en una mezcla de ambos, pero los archivos init del módulo deben estar en Python. Establecer un nuevo módulo con dichos archivos init es sencillo, y se puede hacer manualmente o con la herramienta de construcción de FreeCAD.

Utilización de la herramienta de construcción de FreeCAD

La creación de un nuevo módulo de aplicación en FreeCAD es bastante simple. En árbol de desarrollo de FreeCAD existe la Herramienta de construcción de FreeCAD (fcbt) que hace las parte más importantes para ti. Es un archivo de guión en Python ubicado en 

trunk/src/Tools/fcbt.py

Cuando tu interprete de Python está correctamente instalado puedes ejecutar este archivo de guión desde la línea de comandos con 

python fcbt.py

Mostrará el siguiente menú: 

FreeCAD Build Tool
Usage:
   fcbt <command name> [command parameter] 
possible commands are:
 - DistSrc         (DS)   Build a source Distr. of the current source tree
 - DistBin         (DB)   Build a binary Distr. of the current source tree
 - DistSetup       (DI)   Build a Setup Distr. of the current source tree
 - DistSetup       (DUI)  Build a User Setup Distr. of the current source tree
 - DistAll         (DA)   Run all three above modules
 - BuildDoc        (BD)   Create the documentation (source docs)
 - NextBuildNumber (NBN)  Increase the Build Number of this Version
 - CreateModule    (CM)   Insert a new FreeCAD Module in the module directory

For help on the modules type:
  fcbt <command name> ?

En la línea de comandos introduce CM para comenzar la creación de un módulo: 

Insert command: CM

Te pedirá que especifiques un nombre para tu nuevo módulo. Vamos a llamarlo TestMod por ejemplo: 

Please enter a name for your application: TestMod

Después de pulsar enter fcbt comienza copiando todos los archivos necesarios para tu módulo en una carpeta nueva en 

trunk/src/Mod/TestMod/

Luego todos los archivos se modifican con el nombre de tu nuevo módulo. Lo único que necesitas hacer ahora es añadir los dos nuevos proyectos "appTestMod" y "appTestModGui" a tu espacio de trabajo (en Windows) o a tus objetivos de makefile (unix). Eso es!

Establecer un nuevo módulo manualmente

Necesitas dos cosas para crear un nuevo módulo:

  • Un nuevo directorio en el directorio Mod de FreeCAD (ya sea en RutadeInstalación/FreeCAD/Mod o en RutadeUsuario/.FreeCAD/Mod). Puedes denominarlo como quieras.
  • Dentro de dicho directorio, un archivo InitGui.py. Este archivo será ejecutado automáticamente en el inicio de FreeCAD (por ejemplo, pon el print("hello world") dentro)

Adicionalmete, también puedes poner un archivo Init.py. La diferencia es que, el archivo InitGui.py está cargado sólo cuando FreeCAD se ejecuta en modo interfaz gráfica de usuario, el archivo Init.py se carga siempre. Pero si vamos a crear un entorno, lo pondremos en el InitGui.py, porque los entornos se usan sólo en modo interfaz gráfica de usuario, por supuesto.

Creación de un nuevo entorno

Dentro del archivo InitGui.py, una de las primeras cosas que querrás hacer es definir un entorno. Aquí tienes el mínimo código que puedes utilizar: 

class MyWorkbench ( Workbench ):
	"My workbench object"
	Icon = """
			/* XPM */
			static const char *test_icon[]={
			"16 16 2 1",
			"a c #000000",
			". c None",
			"................",
			"................",
			"..############..",
			"..############..",
			"..############..",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"................",
			"................"};
			"""
	MenuText = "My Workbench"
	ToolTip = "This is my extraordinary workbench"

       def GetClassName(self):
               return "Gui::PythonWorkbench"
	
	def Initialize(self):
		import myModule1, myModule2
		self.appendToolbar("My Tools", ["MyCommand1","MyCommand2"])
		self.appendMenu("My Tools", ["MyCommand1","MyCommand2"])
		Log ("Loading MyModule... done\n")

	def Activated(self):
               # do something here if needed...
		Msg ("MyWorkbench.Activated()\n")

	def Deactivated(self):
               # do something here if needed...
		Msg ("MyWorkbench.Deactivated()\n")

FreeCADGui.addWorkbench(MyWorkbench)

El entorno debe tener todos estos atributos definidos:

  • El atributo de icono es una imagen XPM (La mayoría de programas como GIMP pueden convertir una imagen a formato xpm, el cual es un archivo de texto. Puedes entonces pegar el contenido aquí)
  • MenuText es el nombre del entorno tal como aparece en la lista de entornos
  • Tooltip aparece cuando pasas sobre el con el ratón
  • Initialize() se ejecuta en la carga de FreeCAD, y debe crear todos los menús y barras de herramientas que el entorno va a utilizar.Si vas a crear tu propio módulo en C++, también puedes definir tus menús y barras de herramientas dentro del módulo C++, no en el archivo InitGui.py. Lo importante es si están creados o no cuando el módulo es activado.
  • Activated() se ejecuta cuando el usuario cambia a tu entorno
  • Deactivated() se ejecuta cuando el usuario cambia de tu entorno a otro entorno o abandona FreeCAD

Creación de comandos de FreeCAD en Python

Normalmente defines todas las herramientas (denominadas comandos en FreeCAD) en otro módulo, luego lo importas antes de la creación de las barras de herramientas y menús. Este es el mínimo código que puedes utilizar para definir un comando: 

import FreeCAD,FreeCADGui

class MyTool:
	"My tool object"

       def GetResources(self):
               return {"MenuText": "My Command",
                       "Accel": "Ctrl+M",
                       "ToolTip": "My extraordinary command",
                       "Pixmap"  : """
			/* XPM */
			static const char *test_icon[]={
			"16 16 2 1",
			"a c #000000",
			". c None",
			"................",
			"................",
			"..############..",
			"..############..",
			"..############..",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"......####......",
			"................",
			"................"};
			"""}

       def IsActive(self):
               if FreeCAD.ActiveDocument == None:
                       return False
               else:
                       return True

	def Activated(self):
               # do something here...

FreeCADGui.addCommand('MyCommand1',MyTool())
  • El método GetResources() debe devolver un diccionario con atributos visuales de tu herramienta. Accel define un atajo de teclado pero no es obligatorio.
  • El método IsActive() define si el comando está activo o desactivado en los menús y barras de herramientas.
  • El método Activated() se ejecuta cuando el comando se llama a través de un botón de una barra de herramientas o menú o incluso a través de un archivo de guión.

Creación de comandos de FreeCAD en C++

Pendiente de documentar

Traducciones disponibles:

Prueba primero

Antes de que pruebes con la depuración utiliza el marco de pruebas para verificar si los test estándar funcionan correctamente. Si no es posible que la instalación esté rota.


Línea de comandos

El depurador de FreeCAD está soportado por unos cuantos mecanismos internos. La versión en línea de comandos de FreeCAD opciones para soporte de depuración:

-v
Con la opción "v" FreeCAD ofrece una salida más verbosa.
-l
Con la opción "l" FreeCAD escribe información adicional a un archivo de registro.
Traducciones disponibles:

Introducción

FreeCAD incorpora un extenso entorno de pruebas. Las pruebas se basan en un conjunto de archivos de guión de Python ubicados en el módulo test.

Traducciones disponibles:

Este artículo describe el Marcado de FreeCAD. Marcado significa comenzar tu propia aplicación basada en FreeCAD. Esto puede ser sólo tu propio ejecutable o pantalla de bienvenida hasta un programa completo adaptado. En base a la arquitectura flexible de FreeCAD es sencillo de utilizar como base para tus propios programas de propósito especial.

General

La mayoría del marcado se realiza en MainCmd.cpp o MainGui.cpp. Estos proyectos generan los archivos ejecutables de FreeCAD. Para crear tu propia Marca simplemente copia los proyectos Main o MainGui y dale al ejecutable un nombre diferente, e.g. FooApp.exe. La configuración más importante para una nueva apariencia puede realizarse en una lugar de la función main(). Aquí está la sección de código que controla el marcado: 

int main( int argc, char ** argv )
{
  // Name and Version of the Application
  App::Application::Config()["ExeName"] = "FooApp.exe";
  App::Application::Config()["ExeVersion"] = "0.7";

  // set the banner (for loging and console)
  App::Application::Config()["ConsoleBanner"] = sBanner;
  App::Application::Config()["AppIcon"] = "FCIcon";
  App::Application::Config()["SplashPicture"] = "FooAppSplasher";
  App::Application::Config()["StartWorkbench"] = "Part design";
  App::Application::Config()["HiddenDockWindow"] = "Property editor";
  App::Application::Config()["SplashAlignment" ] = "Bottom|Left";
  App::Application::Config()["SplashTextColor" ] = "#000000"; // black

  // Inits the Application 
  App::Application::Config()["RunMode"] = "Gui";
  App::Application::init(argc,argv);

  Gui::BitmapFactory().addXPM("FooAppSplasher", ( const char** ) splash_screen);

  Gui::Application::initApplication();
  Gui::Application::runApplication();
  App::Application::destruct();

  return 0;
}

La primera entrada de Config define el nombre del programa. Este no es el nombre del ejecutable, el cual puede cambiarse renombrándolo o por la configuración del compilador, sino el nombre que es mostrado en la barra de tareas en Windows o en la lista de programas en los sistemas Unix.

Las siguientes líneas definen las entradas de Config de tu aplicación FooApp. Una descripción de Config y sus entradas se encuentra en Inicio y Configuración.

Imagenes

Todos los recursos de imágenes están compilados en FreeCAD. Esto reduce el tiempo de carga y mantiene la instalación compacta. Las imágenes están incluidas en formato XPM el cual es básicamente un formato de texto que utiliza sintaxis de C. Puedes dibujar estas imágenes con un editor de texto, pero es más confortable crear las imágenes con tu aplicación de gráficos preferida y convertirlas después a formato XPM.

El programa de imágenes de GNU Gimp puede guardar archivos XPM.

Para la conversión puedes utilizar la herramienta ImageConv que está incluida en FreeCAD. Puedes encontrarla en 

/trunk/src/Tools/ImageTools/ImageConv

No sólo convierte imágenes sino que también actualiza automáticamente el archivo BmpFactoryIcons.cpp, donde están registradas las imágenes. El uso habitual es tan simple como en el siguiente ejemplo: 

ImageConv -i InputImage.png -o OutputImage.xpm

Esto convierte el archivo InputImage.png en formato XPM y escribe el resultado al archivo OutputImage.xpm.

La línea: 

Gui::BitmapFactory().addXPM("FooAppSplasher", ( const char** ) splash_screen);

en la función main() entonces incluye la imagen en el BitmapFactory de FreeCAD.

Iconos

La principal aplicación de los iconos FCIcon que aparecen en las ventanas de títulos y otros lugares está definida en 

/trunk/src/Gui/Icons/images.cpp

y comienza con la línea 

static const char *FCIcon[]={

Puedes reemplazarla con tus iconos preferidos, recompilar FreeCAD y el siguiente paso para crear tu propia Marca está terminado. Existen muchos otros iconos en este archivo que podrías cambiar a tu gusto.

Si necesitas añadir nuevos iconos, tienes que registrarlos en 

/trunk/src/Gui/Icons/BmpFactoryIcons.cpp

así podrás acceder a ellos desde FreeCAD.

Imagen de fondo

La imagen de fondo aparece, cuando no está abierto ninguna ventana de documento. Al igual que la imagen de bienvenida está definida en developers.h en la sección que comienza con: 

static const char* const background[]={

Deberías seleccionar una imagen de bajo contraste para el fondo. De otro modo puede molestar al usuario.

Traducciones disponibles:

Localización es, en general, el proceso de proporcionar un software con una interfaz de usuario en múltiples lenguajes. En FreeCAD puedes establecer el idioma de la interfaz de usuario en Editar→Preferencias → aplicación. FreeCAD utiliza Qt para habilitar el soporte para varios idiomas. En Unix / Linux, FreeCAD utiliza la configuración regional actual de tu sistema por defecto.

Cómo ayudar a traducir FreeCAD

Una de las cosas mas importantes que puedes hacer por FreeCAD si no eres programador, es ayudar a traducir el programa a tu idioma. Hacerlo es ahora más fácil que nunca, con el uso de Crowdin], un sistema colaborativo de traducción en línea.

Como traducir

  • Vete a la página del Proyecto de traducción de FreeCAD en Crowdin;
  • Ingresa creando un nuevo perfil de usuario, o utilizando una cuenta de una tercera-parte, como tu dirección de gMail;
  • Haz Click en el idioma en el que quieres trabajar;
  • Comienza la traducción haciendo clic en el boton Translate próximo a uno de los archivos. Por ejemplo, FreeCAD.ts que contiene las cadenas de texto para el GUI (interfaz gráfico de usuario) principal de FreeCAD.
  • Puedes elegir entre las traducciones existentes, o crear la tuya propia.


Traducción con Qt-Linguist (forma antigua- OBSOLETO)

La siguiente información no tiene porque ser utilizada nunca más y probablemente se convierta en obsoleta. Se mantiene aquí para que los programadores puedan conocer cómo funciona.

  • Abre todos los directorios de lenguaje de FreeCAD que se muestran abajo
  • Verifica que un archivo .ts con tu código de lenguaje no existe ("fr" para francés, "de" para alemán, etc...)
  • Si existe, puedes descargar el archivo, si quieres modificar/revisar/mejorar la traducción (pulsa en el archivo y descargalo).
  • Si no existe, descarga el archivo .ts si código de lenguaje (o cualquier otro .ts disponible, también funcionará)
  • Renombra ese archivo con tu código de lenguaje
  • Abrelo con el programa Qt-Linguist
  • Inicia la traducción (Qt Linguist es muy sencillo de utilizar)
  • Una vez esté completamente terminada, guarda tu archivo
  • Envíanos los archivos así podremos incluirlos en el código fuente de FreeCAD beneficiando también a otros usuarios.

Archivos de traducción disponibles

Preparando tus propios módulos/aplicaciones para la traducción

Prerequisitos

Para realizar la localización de tu módulo de aplicación necesitas unas utilidades que vienen con Qt. Puedes descargarlos desde Trolltech-Website, pero también están contenidos en LibPack:

qmake
Genera los archivos de proyecto
lupdate
Extrae o actualiza los textos originales en tu proyecto escaneando el código fuente
Qt-Linguist
'Qt-Linguist es muy sencillo de utilizar y te ayuda en la traducción con buenas características como un libro de frases para las expresiones habituales.

Setup del proyecto

Para iniciar la localización de tu proyecto ve al GUI-Part de tu módulo y escribe en la línea de comandos: 

qmake -project

Esto escanea tu directorio de proyecto buscando archivos que contengan cadenas de texto y crea un archivo de proyecto como el del siguiente ejemplo: 

######################################################################
# Automatically generated by qmake (1.06c) Do 2. Nov 14:44:21 2006
######################################################################

TEMPLATE = app
DEPENDPATH += .\Icons
INCLUDEPATH += .

# Input
HEADERS += ViewProvider.h Workbench.h
SOURCES += AppMyModGui.cpp \
           Command.cpp \
           ViewProvider.cpp \
           Workbench.cpp
TRANSLATIONS += MyMod_de.ts

Puedes añadir archivos aquí manualmente. Esta sección TRANSLATIONS contiene una lista de los archivos con la traducción para cada idioma. En el ejemplo de arriba MyMod_de.ts es la traducción al alemán.

Ahora necesitas ejecutar lupdate para extraer todas las literales de las cadenas de texto en tu interfaz gráfica de usuario. La ejecución de lupdate después hacer cambios en el código fuente es siempre segura ya que nunca borra cadenas de texto de tu traducción. Sólo añade nuevas cadenas de texto.

Ahora necesitas añadir los archivos .ts a tu proyecto de VisualStudio. Especifica el siguiente método de construcción personalizado para ellos: 

python ..\..\..\Tools\qembed.py "$(InputDir)\$(InputName).ts"
                "$(InputDir)\$(InputName).h" "$(InputName)"

Nota: Introduce el texto en una única línea de comandos, el salto de línea es sólo para propósitos de presentación.

Compilando el archivo .ts de los ejemplos de arriba, se crea un archivo de encabezamiento MyMod_de.h. El mejor sitio para añadirlo es en App<Modul>Gui.cpp. En nuestro ejemplo esto podría ser AppMyModGui.cpp. Allí añades la línea 

new Gui::LanguageProducer("Deutsch", <Modul>_de_h_data, <Modul>_de_h_len);

para publicar tu traducción en la aplicación.

Configurando los archivos de Python para la traducción

Para facilitar el proceso de localización de los archivo .py puedes utilizar la herramienta "pylupdate4" que acepta uno o más archivos .py. Con la opción -ts puedes preparar/actualizar uno o más archivos .ts. Por ejemplo para preparar un archivo .ts para la traducción al francés simplemente introduce lo siguiente en la línea de comandos: 

pylupdate4 *.py -ts YourModule_fr.ts

la herramienta pylupdate escaneará tus archivos .py para las funciones translate() o tr() y crea un archivo YourModule_fr.ts. Este archivo puede ser el traducido con QLinguist y un archivo YourModule_fr.qm producido desde QLinguist o con el comando 

lrelease YourModule_fr.ts

Ten en cuenta que la herramienta pylupdate4 no es muy buena reconociendo las funciones translate(), estas necesitan formatearse de forma muy específica (mira los archivos del módulo de croquizado como ejemplo). Dentro de tu archivo, puedes configurar un traductor como este (después de cargar tu QApplication pero ANTES de crear cualquier complemento o widget Qt): 

translator = QtCore.QTranslator()
translator.load("YourModule_"+languages[ln])
QtGui.QApplication.installTranslator(translator)

Opcionalmente, también puedes crear el archivo XML Draft.qrc con este contenido: 

<RCC>
<qresource prefix="/translations" > 
<file>Draft_fr.qm</file> 
</qresource> 
</RCC>

y ejecutar pyrcc4 Draft.qrc -o qrc_Draft.py crea un gran archivo en Python conteniendo todos los recursos. Por otra parte esta aproximación también funciona para poner archivos de iconos en un archivo de recursos

Traduciendo la wiki

Esta wiki contiene un montón de contenido. El material más importante y actualizado es recopilado en el manual.

De modo que el primer paso es comprobar si la traducción del manual ya se ha comenzado para tu idioma (mira en la barra de la izquierda bajo "manual").

Si no, dirígete al foro y comenta que quieres iniciar una nueva traducción, crearemos la configuración básica para el idioma en el que quieras trabajar.

Tu debes luego conseguir permisos de edición del wiki.

Si tu idioma ya está listado, mira que páginas aún faltal por traducir (estarán listadas en rojo). La técnica es simple: Entra en una página en rojo, y copia/pega el contenido de la correspondiente página en inglés, y comienza a traducir.

No olvides incluir todas las etiquetas y plantillas de la página original en inglés. Algunas de dichas plantillas tendrán un equivalente en tu lenguaje (por ejemplo, existe una plantilla de Docnav en Español llamada Docnav/es). Deberías utilizar una barra inclinada y el código de tu idioma en casi todos los enlaces. Mira otras páginas ya traducidas para ver como lo hicieron.

Añade una barra inclinada y el código de tu idioma en las categorías, como [[Category:Developer Documentation/es]]

Luego, una vez has traducido la página, debes añadir un vínculo en la página original en inglés a tu traducción, así los lectores sabrán que existe una versión traducida disponible, utilizando la plantilla {{languages}} template. Mira como otros traductores lo hicieron para hacer lo mismo.

  • En la página original en inglés añade tu idioma en orden alfabético: {{languages | {{es|Localisation/es}} {{fr|Localisation/fr}} {{jp|Localisation/jp}} {{se|Localisation/se}} }}
  • En la página que has traducido deberías utilizar tu plantilla de idiomas y poner el inglés en primer lugar y el resto de idiomas después en orden alfabético: {{languages/fr | {{en|Localisation}} {{es|Localisation/es}} {{jp|Localisation/jp}} {{se|Localisation/se}} }}

Y si no estas seguro, dirígete a los foros y pregunta a la gente para verificar lo que hiciste y que te digan si está bien o no.

Tres plantillas son utilizadas normalmente en las páginas del manual. Estas tres plantillas tienen versiones localizadas (Template:Docnav/es, Template:Es, etc...)

  • Template:Docnav : es la barra de navegación en la parte inferior de las páginas, mostrando las páginas anterior y siguiente.
  • Template:Languages : esta plantilla debe estar en las páginas originales, para indicar al lector que existe una traducción. La versión localizada de esta plantilla Template:Languages/es debe por contra estar situada en la página traducida, enlazada a la página original en inglés.
  • Template:en : Existe un de estas para cada idioma. Deben estar situadas dentro de la plantilla de idioma.

Convenciones de los nombres de las páginas

Por favor, apunta esto, debido a limitaciones en la implementación en Sourceforge del motor de MediaWiki, necesitamos que todas tus páginas mantengan el nombre homólogo de la página en inglés, añadiéndole una barra inclinada y tu código de idioma. Por ejemplo, la página traducida para """About FreeCAD""" debería ser """About Freecad/es""" en español, """About FreeCAD/pl""" en polaco, etc. La razón es simple: así si los traductores se van, los administradores del wiki, que no hablan todos los idiomas, sabrán para que son esas páginas. Esto facilitará el mantenimiento y evitará páginas perdidas.

Si quieres que la plantilla Docnav muestre las páginas vinculadas en tu lenguaje, puedes utilizar páginas redirigidas. Estas son básicamente enlaces a la página actual. Aquí está un ejemplo con la página en francés para About FreeCAD.

  • La página About FreeCAD/fr es la página con contenido
  • La página a À propos de FreeCAD contiene este código: 
#REDIRECT [[About FreeCAD/fr]]
  • En la página About FreeCAD/fr page, el código de Docnav se parecerá a esto: 
{{docnav/fr|Bienvenue sur l'aide en ligne|Fonctionnalités}}

La página "Bienvenue sur l'aide en ligne" redirige a Online Help Startpage/fr, y la página "Fonctionnalités" redirige a Feature list/fr.

Si no estas seguro de como proceder, no dudes en solicitar ayuda en los foros.

Traducciones disponibles:

El interprete de Python dentro de FreeCAD puede extenderse fácilmente añadiendo nuevos módulos a tu instalación de Python. Esos módulos se detectarán automáticamente y utilizarán por FreeCAD.

Todos los módulos de Python se pueden utilizar desde FreeCAD, pero algunos de ellos, listados abajo, tienen una importancia especial porque permiten a los programas de Python tener acceso completo a las funcionalidades principales de FreeCAD. También se pueden encontrar ejemplos de uso de dichos módulos en la página de Pedazos de código.

Nota: de los siguientes módulos, Pivy está ahora integrado por completo en cualquier paquete de instalación de FreeCAD, y PyQt4 también está integrado en el paquete de instalación de Windows.

PyQt4

Web: http://www.riverbankcomputing.co.uk/pyqt

PyQt (versión 4) es una biblioteca de vinculación de Python que permite a los programas acceder, crear o modificar interfaces Qt. Ya que la interfaz de FreeCAD está construida con Qt, la instalación de PyQt4 en tu sistema permitirá a los programas de Python dentro de FreeCAD acceder a todos los interfaces, modificar sus partes, crear nuevos complementos (widgets) o recoger información desde partes del interfaz.

PyQt se distribuye bajo un sistema de múltiples licencias, el mismo sistema que es utilizado por Qt. En resumen, existe una versión comercial y una versión libre GPL. Si quieres utilizarlo para crear aplicaciones comerciales (de código cerrado), necesitas comprar la licencia comercial, en otro caso puedes simplemente instalar y utilizar libremente la versión GPL.

Instalación

Antes de la instalación de PyQt4, obviamente necesitas un entorno de Python instalado y trabajando.

Linux

El modo más sencillo de instalar PyQt4 es a través del gestor de paquetes de tu distribución. En sistemas Debian/Ubuntu, el nombre del paquete es generalmente python-qt4, mientras que en sistemas basados en RPM se denomina pyqt4. Las dependencias necesarias (Qt y SIP) se cogerán automáticamente.

Windows

El programa se puede descargar desde aquí. Necesitas instalar las bibliotecas Qt y SIP antes de instalar (pendiente de documentar).

Utilización

Una vez está instalado, puedes comprobar que todo está funcionando escribiendo en la consola de Python de FreeCAD: 

import PyQt4

Para acceder a la interfaz de FreeCAD, escribe: 

from PyQt4 import QtCore,QtGui
app = QtGui.qApp
FreeCADWindow = app.activeWindow()

Ahora puedes comenzar a explorar la interfaz con el comando dir(). Puedes añadir nuevos elementos, como complementos (widget) personalizados, con comandos como: 

FreeCADWindow.addDockWidget(QtCore.Qt.RghtDockWidgetArea,my_custom_widget)

Documentación

Más tutoriales de pyQt4 (incluyendo cómo construir interfaces con Qt Designer para utilizar con Python):

http://www.riverbankcomputing.co.uk/static/Docs/PyQt4/html/classes.html - la referencia oficial del API de PyQt4

http://www.rkblog.rk.edu.pl/w/p/introduction-pyqt4/ - una simple introducción

http://www.zetcode.com/tutorials/pyqt4/ - un tutorial en profundidad muy completo


Pivy

web: http://pivy.coin3d.org/

Pivy es una biblioteca de vinculación de coin para Python, soportada oficialmente por coin. El propio Coin es un juego de herramientas para construir aplicaciones 3D en OpenGL. Es el juego de herramientas que utiliza FreeCAD para dibujar su escena 3D en la pantalla. Instalando Pivy en tu sistema permitirá a los programas en Python acceder a la escena gráfica de FreeCAD, dibujar nuevos objetos en la escena y utilizar el amplio rango de herramientas de Coin disponibles para operaciones de dibujo. Coin está basado en el lenguaje de descripción de la escena de Open Inventor. Pivy se utiliza por el módulo de croquizado 2D de FreeCAD (y también por el módulo completo), así que es necesario si quieres utilizar cualquier herramienta de dichos módulos.

Es importante saber que FreeCAD sólo utiliza coin para la representación de los objetos en la pantalla, la cual está separada de la definición de los objetos. Esto dignifica que pivy no será capaz de modificar objetos existentes, ni de crear objetos de FreeCAD válidos. Pero puede utilizarse para dibujar todo tipo de cosas temporales en la pantalla, como ejes, parrillas, manipuladores, geometría constructiva, etc...

Pivy, al igual que Coin, se distribuye bajo licencia GPL.

Instalación

Requisitos previos

Creo que antes de compilar Pivy querrás tener Coin y SoQt instalados.

Para construirlo en Mac es suficiente instalar el paquete binario de Coin3. Intentar instalar Coin desde MacPorts es problemático: añadir un montón de paquetes de X Windows y finalmente se cuelga con un error de script.

Para Fedora encontré un RPM con Coin3.

SoQt compilado desde código fuente funciona bien en Mac y Linux.

Debian & Ubuntu

Empezando con Debian Squeeze y Ubuntu Lucid, pivy está disponible directamente desde los repositorios oficiales, ahorrándonos un montón de dificultades. Mientras tanto, puedes descargar uno de los paquetes que hemos creado (para Debian y Ubuntu karmic) disponibles en la página de Descargas, o compilarlo tu mismo.

El mejor modo de compilar pivy siomplemente es aprovechar el paquete de código fuente de Debian para pivy y crear un paquete con debuild. Es el mismo código fuente desde la web oficial de pivy, pero la gente de Debian han creado varios parches adicionales. También se compila bien en Ubuntu karmic: http://packages.debian.org/squeeze/python-pivy (descarga los archivos .orig.gz y .diff.gz, luego descomprimelos, y aplica .diff al código fuente: ve a las carpetas del código fuente descomprimido de pivy, y aplica el parche .diff: 

patch -p1 < ../pivy_0.5.0~svn765-2.diff

luego 

debuild

para tener pivy correctamente construido en un paquete oficial de instalación. A continuación, simplemente instala el paquete con gdebi.

Otras distribuciones Linux

Primero consigue la última versión del código fuente de los repositorios del proyecto: 

 hg clone http://hg.sim.no/Pivy/default Pivy

En marzo de 2012, la última versión es Pivy-0.5

Luego necesitas una herramienta llamada SWIG para generar el código C++ para la vinculación de Python. Pivy-0.5 informa que sólo ha sido comprobado con SWIG 1.3.31, 1.3.33, 1.3.35, y 1.3.40. Así que puedes descargar el código fuente en un tarball para una de dichas versiones anteriores desde http://www.swig.org. Luego descomprimelo y desde la línea de comandos haz lo siguiente (como root): 

./configure
make
make install (or checkinstall if you use it)

Esto tardará unos segundos en construirse.

Como alternativa, puedes tratar de construir con un SWIG más reciente. En marzo de 2012, una versión típica del repositorio es la 2.0.4. Pivy tiene un problema menor de compilación con SWIG 2.0.4 en Mac OS (mira más abajo) pero parece construirse bien en Fedora Core 15.

Después de eso ve al archivo que va a los recursos de pivy y ejecuta 

python setup.py build

lo que creará los archivos fuente. Ten en cuenta que la construcción puede producir miles de advertencias, pero afortunadamente no hay errores.

Es posible que esto esté obsoleto, pero puedes llegar a un error de compilación donde una constante de tipo caracter (char) no puede ser convertida en una 'char*'. Para solucionarlo sólo necesitas escribir una constante antes de las líneas apropiadas. Hay 6 líneas que corregir.

Después de eso, instalar por publicación (como root): 

python setup.py install (or checkinstall python setup.py install)

Eso es todo, pivy está instalado.

Mac OS

Estas instrucciones puede que no estén completas. Algo parecido funciona para OS 10.7 en marzo de 2012. He utilizado MacPorts para los repositorios, pero también deberían funcionar otras opciones.

Para Linux, consigue la última vcersión del código fuente: 

hg clone http://hg.sim.no/Pivy/default Pivy

Si no tienes hg, puedes conseguirlo desde MacPorts: 

port install mercurial

Luego, como se indica arriba, necesitas SWIG. Debería ser cuestión de hacer: 

port install swig

He encontrado que también necesitaba: 

port install swig-python

En marzo de 2012, la versión de SWIG en MacPorts es la 2.0.4. Como se ha indicado arriba para Linux, podría ser mejor que descargaras una versión más antigua. SWIG 2.0.4 parece tener un error que detiene la construcción de Pivy. Mira el primer mensaje en este enlace: https://sourceforge.net/mailarchive/message.php?msg_id=28114815

Esto se puede corregir editando las dos ubicaciones de código fuente para añadir: *arg4, *arg5 en lugar de arg4, arg5. Ahora Pivy debería construirse: 

python setup.py build
sudo python setup.py install

Windows

Asumiendo que utilizas Visual Studio 2005 o superior deberías abrir una ventana de comandos con 'Visual Studio 2005 Command prompt' desde el menú Herramientas. Si el interprete aún no está en el sistema, haz 

set PATH=path_to_python_2.5;%PATH%

Para tener pivy funcionando deberías conseguir las últimas fuentes desde los repositorios del proyect: 

svn co https://svn.coin3d.org/repos/Pivy/trunk Pivy

Luego necesitas una herramienta denominada SWIG para generar el ódigo C++ para la vinculación con Python. Es recomendable utilizar la versión 1.3.25 de SWIG, no la última versión, porque de momento pivy sólo funciona correctamente con con la versión with 1.3.25. Descarga los binarios para 1.3.25 desde http://www.swig.org. Luego descomprimelo y desde la línea de comandos añádelo al sistema path 

set PATH=path_to_swig_1.3.25;%PATH%

y establece COINDIR a la ruta aproviada 

set COINDIR=path_to_coin

En Windows el archivo de configuración de pivyespera SoWin en lugar de SoQt por defecto. No he encontrado una manera obvia para construirlo con SoQt, así que he modificado el arhivo setup.py directamente. En la línea 200 simplemente elimina la parte 'sowin' : ('gui._sowin', 'sowin-config', 'pivy.gui.') (no elimines los paréntesis de cierre).

Después de esto ve a las fuentes de pivy y ejecuta 

python setup.py build

lo cual crea los archivos de fuente. Puedes llegar a un error de compilación de 'Varios archivos de cabecera no se han encontrado'. En este caso ajusta la variable INCLUDE 

set INCLUDE=%INCLUDE%;path_to_coin_include_dir

y si las cabeceras de SoQt no están en el mismo sitio que las cabeceras de Coin también 

set INCLUDE=%INCLUDE%;path_to_soqt_include_dir

y finalmente las cabeceras de Qt 

set INCLUDE=%INCLUDE%;path_to_qt4\include\Qt

Si estas utilizando la versión Express Edition de Visual Studio puedes tener una excepción de error de clave de Python. En este caso tendrás que modificar unas cuantas cosas en msvccompiler.py situado en la instalación de Python.

Ve a la línea 122 y reemplaza la línea 

vsbase = r"Software\Microsoft\VisualStudio\%0.1f" % version

con 

vsbase = r"Software\Microsoft\VCExpress\%0.1f" % version

Luego prueba de nuevo. Si te da un segundo error como 

error: Python was built with Visual Studio 2003;...

debes reemplazar también la línea 128 

self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv1.1")

con 

self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv2.0")

Intenta de nuevo. Si tienes un nuevo error como 

error: Python was built with Visual Studio version 8.0, and extensions need to be built with the same version of the compiler, but it isn't installed.

entonces deberías comprobar las variables de entorno DISTUTILS_USE_SDK y MSSDK con 

echo %DISTUTILS_USE_SDK%
echo %MSSDK%

If not yet set then just set it e.g. to 1 

set DISTUTILS_USE_SDK=1
set MSSDK=1

Ahora, debes encontrar un error de compilación donde una constante de tipo char no se puede convertir en char. Para solucionarlo necesitas escribir una constante antes de las líneas apropiadas. Hay 6 líneas que corregir. Después copia el directorio de pivy generado a un lugar donde el interprete de Python de FreeCAD lo pueda encontrar.

Utilización

Para tener Pivy acceso a la escena gráfica de FreeCAD haz lo siguiente: 

from pivy import coin
App.newDocument() # Open a document and a view 
view = Gui.ActiveDocument.ActiveView 
FCSceneGraph = view.getSceneGraph() # returns a pivy Python object that holds a SoSeparator, the main "container" of the Coin scenegraph
FCSceneGraph.addChild(coin.SoCube()) # add a box to scene

Ahora puedes explorar FCSceneGraph con el comando dir().

Documentación

Desafortunadamente la documentación sobre pivy es casi inexistente en la redt. Pero podrías encontrar la documentación de Coin útil, ya que pivy simplemente traduce las funciones de Coin, los nodos y métodos en Python, todo mantiene el mismo nombre y propiedades, teniendo en cuenta la diferencia de sintaxis entre C y Python:

http://doc.coin3d.org/Coin/classes.html - Referencia del API de Coin3D

http://www-evasion.imag.fr/~Francois.Faure/doc/inventorMentor/sgi_html/index.html - The Inventor Mentor - La "biblia" del lenguaje de descripción de escena de Inventor.

También puedes echar un vistazo al archivo Draft.py en el directorio de FreeCAD Mod/Draft, ya que hace un uso importante de pivy.

pyCollada

pyCollada es una biblioteca de Python que permite a los programas leer y escribir archivos de Collada (*.DAE). Cuando pyCollada está instalado en tu sistema, FreeCAD (Disponible en la versión 0.13 ) lo detectará y añadirá opciones de importación y exportación para manejar la apertura y guardado en el formato de archivos de Collada.

Instalación

Pycollada no está normalmente disponible en los repositorios de las distribuciones de Linux, pero ya que está creado únicamente por archivos de Python, no es necesaria su compilación, y es sencillo de instalar. Tienes dos métodos, o directamente desde el repositorio ofician en Git de pycollada, o con la herramienta easy_install.

Linux

En ambos casos, necesitaras tener los siguientes paquetes ya instalados en tu sistema: 

python-lxml 
python-numpy
python-dateutil
Desde el repositorio de Git
git clone git://github.com/pycollada/pycollada.git pycollada
cd pycollada
sudo python setup.py install
Con easy_install

Asumiendo que ya tienes una instalación completa de Python, la utilidad easy_install ya debería estar presente: 

easy_install pycollada

Windows

Pendiente de documentar

IfcOpenShell

Pendiente de documentar

Traducciones disponibles:

Créditos

Aquí se puede ver un resumen de las personas o compañías que han contribuido a FreeCAD. Para los créditos de las bibliotecas utilizadas ver Bibliotecas de terceros.

Desarrollo

Responsables del proyecto

Responsables del proyecto de FreeCAD

Más adelante pueden tener responsabilidades sobre el módulo base.

Principales desarrolladores

Personas que trabaja regularmente en el código de FreeCAD

Otros programadores

Personas que han contribuido con código al proyecto de FreeCAD:

  • Graeme van der Vlugt
  • Berthold Grupp
  • Georg Wiora
  • Martin Burbaum
  • Jacques-Antoine Gaudin
  • Ken Cline
  • Dmitry Chigrin
  • Remigiusz Fiedler (DXF-parser)

Compañías

Compañías que han donado código o desarrolladores:

  • Imetric 3D

Comunidadd

Personas de la comunidad que han aportado una gran cantidad de esfuerzo ayudando al proyecto de FreeCAD

Traducciones disponibles:
Retrieved from "http://sourceforge.net/apps/mediawiki/free-cad/index.php?title=Manual/es"
Personal tools

© 2013 SourceForge. All Rights Reserved. SourceForge is a Dice Holdings, Inc. company   Terms of Use - Privacy Policy - Cookies/Opt Out