Manual/it

From FreeCAD Documentation
Jump to: navigation, search

Manuale di FreeCAD

Questo è il manuale FreeCAD. Comprende le parti essenziali del Wiki della documentazione di FreeCAD.

Questa versione è stata creata principalmente per essere stampata come un unico grande documento.

Se si sta leggendo questo online, si consiglia di andare direttamente alla Guida in linea, che è più facile da esplorare.


Arrow-left.svg Indice dei contenuti Pagina precedente:
Pagina successiva: Informazioni su FreeCAD Arrow-right.svg
150

Benvenuti nelle pagine dell'aiuto in linea di FreeCAD

Questa documentazione è stata creata automaticamente a partire dai contenuti del wiki ufficiale di FreeCAD, raggiungibile anche attraverso l'indirizzo http://www.freecadweb.org/wiki/index.php?title=Main_Page. Poiché il wiki on-line è aggiornato e revisionato con continuità dalla community di FreeCAD, è possibile che la documentazione disponibile on-line sia più esaustiva e completa. In ogni caso crediamo che questa documentazione contenga tutte le informazioni che possono essere utili. Se così non fosse è possibile consultare il forum di FreeCAD, dove qualcuno sarà sicuramente in grado di aiutarvi.

Come utilizzare FreeCAD

Questo manuale è diviso in varie sezioni: Introduzione, utilizzo, scripting e sviluppo. Le ultime tre sezioni sono rivolte a diverse tipologie di utenti: utilizzatore, interessato al semplice utilizzo del programma; power-user, interessato allo sviluppo di script ed a personalizzazioni avanzate dell'ambiente; sviluppatore, che considera FreeCAD una base di partenza per la stesura di applicazioni personali per gli scopi più disparati. Se siete del tutto nuovi in FreeCAD vi consigliamo di partire dalla sezione: Introduzione.

Contribuire

Come sicuramente vi sarà capitato di constatare, i programmatori sono pessimi scrittori di guide e di help! Per loro, naturalmente, è tutto estremamente chiaro, avendo sviluppato personalmente tutte le caratteristiche del programma. E' quindi fondamentale, che gli utenti più esperti diano una mano nella stesura degli help e nella loro correzione. Già, ci riferiamo proprio a te! Ti stai chiedendo come? Semplice, accedi alla home del wiki dall'indirizzo http://www.freecadweb.org/wiki/index.php nella sezione User. Avrai bisogno di un account di sourceforge per loggarti, dopodiché puoi iniziare a dare il tuo contributo! Inoltre, guarda nella pagina http://www.freecadweb.org/wiki/index.php?title=Help_FreeCAD/it per vedere in quali altri modi si può aiutare FreeCAD.

Arrow-left.svg Indice dei contenuti Pagina precedente:
Pagina successiva: Informazioni su FreeCAD Arrow-right.svg

Introduzione

Arrow-left.svg Benvenuti Pagina precedente:
Pagina successiva: Funzionalità di FreeCAD Arrow-right.svg
Freecad default.jpg

FreeCAD è un software CAD di modellazione parametrica 3D. Lo sviluppo ed il codice sorgente vengono portati aventi tramite la filosofia open source (Licenza LGPL). FreeCAD è studiato per l'ingegneria meccanica e per il product design (progettazione del prodotto) ma si adatta anche a una gamma più ampia di usi in ambito ingegneristico, come l'architettura, l'analisi agli elementi finiti, la stampa 3D e altre attività.

L'utilizzo e le funzioni di FreeCAD sono simili a quelle di Catia, SolidWorks o Solid Edge, e rientra anche nella categoria di MCAD, PLM, CAx e CAE. È un Modellatore parametrico di solidi con una architettura modulare che permette l'aggiunta e lo sviluppo di nuove funzioni con estrema facilità, senza modificare il "cuore" del software.

Come molti modellatori CAD è provvisto di molti componenti 2D per disegnare forme planari o creare disegni di produzione, ma il disegno in 2D (tipo Inkscape o AutoCAD LT) non è lo scopo del software, e non rientrano negli interessi principali neanche le animazione o le mesh edition (come Blender, Maya, 3ds Max, o Cinema 4D), anche se, grazie alla sua estrema flessibilità, FreeCAD può essere molto utile in numerosi altri campi che non fanno parte dei suoi interessi attuali.

FreeCAD utilizza molte delle librerie open-source disponibili nel campo della computazione scientifica. Tra queste Open Cascade Technology (OCCT), un potente kernel CAD, Coin3D, un kit di strumenti per lo sviluppo di grafica 3D compatibile con Open Inventor, Qt, il framework per lo sviluppo di Interfacce Utente, e Python, uno moderno linguaggio di script. FreeCAD può anche essere utilizzato come libreria per altri software.

Inoltre, FreeCAD è multi-piattaforma, ed allo stato attuale è in grado di funzionare senza problemi su Windows, Linux/Unix e Mac OSX, conservando inalterate le caratteristiche e le funzionalità su ognuna di queste piattaforme.

Per ulteriori informazioni su FreeCAD, dare un'occhiata alla lista delle funzioni, alle ultime note di rilascio, e all'articolo per iniziare, o vedere alcuni screenshots.

Informazioni sul progetto FreeCAD

Il progetto FreeCAD è stato avviato nel 2001, come descritto nella pagina Storia di FreeCAD.

FreeCAD è mantenuto e sviluppato da una comunità di sviluppatori appassionati e utenti (vedere la pagina credits). Essi lavorano su FreeCAD volontariamente, nel loro tempo libero. Non possono garantire che FreeCAD contenga o conterrà tutto ciò che si potrebbe desiderare, ma di solito fanno del loro meglio! La comunità si ritrova sul FreeCAD forum, dove sono discusse la maggior parte delle idee e delle decisioni. Sentitevi liberi di unirvi a noi!

Arrow-left.svg Benvenuti Pagina precedente:
Pagina successiva: Funzionalità di FreeCAD Arrow-right.svg

Caratteristiche di FreeCAD

Arrow-left.svg Informazioni su FreeCAD Pagina precedente:
Pagina successiva: Installazione su Windows Arrow-right.svg

Questa è una lista estesa, ma non completa, delle funzionalità (caratteristiche) già implementate in FreeCAD. Se siete interessati a conoscere gli sviluppi futuri è possibile consultare il Piano di sviluppo. Per un approccio sommario alle caratteristiche sono anche disponibili gli screenshot.

Contents

Note di rilascio

Funzioni principali

  • Feature1.jpg
    Un kernel geometrico (nucleo) basato su OpenCasCade permette operazioni complesse su profili di varia natura, anche molto articolati. È presente il supporto nativo al BREP, alle curve e alle superfici NURBS, una vasta gamma di entità geometriche, di operazioni booleane e raccordi, e il supporto interno per i file STEP e IGES.


  • Feature3.jpg
    Un modellatore interamente parametrico. Tutti gli oggetti di FreeCAD sono nativamente parametrici, il che significa che la loro forma può essere basata sulle proprietà e, quando dipendono da altri oggetti, se subiscono delle modifiche possono essere ricalcolati a richiesta, e registrati dall'albero delle operazioni annulla o ripeti. Possono essere aggiunti facilmente nuovi tipi di oggetti, anche quelli completamente programmati in Python


  • Feature4.jpg
    Una architettura modulare permette di estendere le funzioni del programma attraverso l'utilizzo dei plugins. Queste estensioni possono essere complesse, come sono le intere nuove applicazioni programmate in C++ o essere semplici, come gli script Python o le macro auto-registrate. Attraverso l'utilizzo della riga di comando integrata nella GUI, è possibile accedere praticamente a tutte le funzionalità del software per mezzo di semplici comandi Python. Si possono creare e/o modificare oggetti geometrici, interagire con l'ambiente di lavoro o addirittura personalizzare l'interfaccia grafica del programma.


  • Feature5.jpg
    È possibile importare ed esportare molti dei formati standard di rappresentazione 3D, come ad esempio: STEP, IGES, OBJ, STL, DXF, SVG, STL, DAE, IFC oppure OFF, NASTRAN, VRML, oltre al formato nativo di FreeCAD Fcstd. Il livello di compatibilità tra FreeCAD e un formato di file specifico è variabile, dipende dal modulo che lo implementa.


  • Feature7.jpg
    Un ambiente di sketch dotato di strumenti per disegnare sagome in 2D vincolate. Questa funzionalità permette di vincolare in diversi modi le geometrie tracciate e poi di utilizzarle come base per la costruzione delle forme 3D.


  • Feature9.jpg
    Un modulo di simulazione robotica con il quale studiare i movimenti e le traiettorie del manipolatore. È disponibile una interfaccia grafica di questo modulo che permette di manovrare i vari elementi del modello 3D in modo semplice e intuitivo.


  • Feature8.jpg
    Un nuovo modulo comodo per creare fogli di disegno tradizionali con opzioni come viste di dettagli, sezioni trasversali, quotatura e altre, che consente di inserire delle viste 2D dei modelli 3D su un foglio. Questo modulo produce quindi fogli SVG o PDF pronti per l'esportazione. Esiste ancora il vecchio modulo Drawing con i suoi scarni comandi Gui, ma una potente funzionalità Python.


  • Feature-raytracing.jpg
    Un modulo dedicato al rendering per mezzo del quale si possono esportare i modelli 3D ed effettuare renderizzazioni con software di terze parti. Al momento è pienamente supportato solo POV-Ray.


  • Feature-arch.jpg
    Inoltre, è stato avviato lo sviluppo di un modulo di architettura compatibile con il modello BIM e compatibile con l'IFC. Le caratteristiche di questo modulo sono ancora in via di definizione e sono discusse dalla comunità in questa pagina del forum.


  • Feature-CAM.jpg
    Un modulo Path dedicato alle lavorazioni meccaniche, come la fresatura (CAM), in grado di produrre, visualizzare e modificare il Codice G.


Funzioni Generali

  • multipiattaforma. FreeCAD funziona esattamente allo stesso modo su piattaforme Microsoft Windows®, Linux e macOS®.
  • interfaccia grafica completa basata sulla piattaforma Qt e una interfaccia di visualizzazione 3D basata su Open Inventor che garantisce un rendering rapido e permette di accedere facilmente alle varie proiezioni della scena.
  • funziona tramite riga di comando. In modalità riga di comando, FreeCAD viene eseguito senza la sua interfaccia ma con tutti i suoi strumenti di geometria. In questa modalità ha un ingombro di memoria relativamente basso e può essere utilizzato, ad esempio, come server per produrre contenuti per altre applicazioni.
  • può essere importato come un modulo Python. FreeCAD può essere importato in qualsiasi applicazione in grado di eseguire script Python. Come in modalità riga di comando, la parte di interfaccia di FreeCAD non è disponibile, ma tutti gli strumenti di geometria sono accessibili.
  • concepito in Ambienti. Nell'interfaccia di FreeCAD gli strumenti sono raggruppati all'interno di workbenches (ambienti di lavoro). Questo permette che vengano visualizzati soltanto gli strumenti necessari all'azione specifica che si deve compiere, ottenendo un'area di lavoro pulita, facile da gestire e veloce da caricare.
  • plugins e moduli per il caricamento ritardato di funzioni e dati. FreeCAD è diviso in un'applicazione principale con moduli che vengono caricati solo quando è necessario. Quasi tutti gli strumenti e i tipi di geometria sono memorizzati nei moduli. I moduli si comportano come dei plug-in; oltre al caricamento ritardato, è possibile aggiungere o rimuovere singoli moduli da un'installazione di FreeCAD esistente.
  • gestione parametrica degli oggetti. In un documento di FreeCAD tutti gli oggetti possono essere definiti da parametri. Questi parametri possono essere modificati e ricalcolati in qualsiasi momento. Poiché le relazioni tra gli oggetti vengono mantenute, la modifica di un oggetto si propaga automaticamente a qualsiasi oggetto dipendente.
  • creazione parametrica di primitive. Gli oggetti primitivi come box, sfere, cilindri, ecc. possono essere creati specificando i loro vincoli geometrici.
  • operazioni di modifica grafica. FreeCAD può eseguire traslazioni, rotazione, ridimensionamento, mirroring, offset (triviali o come descritte in Jung/Shin/Choi) o anche trasformazione della forma, in qualsiasi piano dello spazio 3D.
  • constructive solid geometry (operazioni booleane). FreeCAD può eseguire operazioni di geometria solida costruttiva (unione, differenza, intersezione).
  • creazione grafica di geometrie piane. Linee, spezzate, rettangoli, b-spline e archi circolari o ellittici possono essere creati graficamente in qualsiasi piano dello spazio 3D
  • modellazione lineare o rivolutiva di estrusioni, sezioni e raccordi.
  • elementi topologici quali vertici, spigoli, contorni e piani facilmente ottenibili anche tramite script Python.
  • test e correzione. FreeCAD dispone di strumenti per il test delle mesh (test solido, test di non-due-varietà, test di auto-intersezione) e per la riparazione di mesh (riempimento del foro, orientamento uniforme).
  • annotazioni. FreeCAD può inserire annotazioni per testo o dimensioni.
  • strumento annulla/ripristina. In FreeCAD si può annullare o ripristinare tutto tramite l'accesso diretto allo storico delle azioni. In questo modo è possibile annullare più modifiche contemporaneamente.
  • gestione delle modifiche. Lo storico annulla/ripristina conserva le informazioni sulle modifiche globali e non sulla singola azione, così ogni singolo strumento può gestire esattamente ciò che deve essere annullato o ripristinato.
  • strumento di sviluppo di script integrato. FreeCAD fornisce un interprete Python integrato nel programma e delle API che coprono la quasi totalità del programma, come ad esempio l'interfaccia, la geometria e la visualizzazione 3D. L'interprete è in grado di gestire singoli comandi così come interi script complessi. Tutti i moduli possono essere gestiti tramite Python.
  • console Python integrata. L'interprete Python include una console completa della funzione di highlight del codice, dell'auto-completamento e anche del class-browser. I comandi, in python, possono essere inviati direttamente dall'interno del programma e essere eseguiti immediatamente. Questa funzione è molto utile per testare al volo il funzionamento di uno script, ma anche per esplorare i contenuti dei moduli di FreeCAD integrati e conoscere a fondo il programma stesso.
  • azioni dell'utente registrate nella console. Tutto ciò che l'utente fa nell'interfaccia di FreeCAD esegue del codice Python, che può essere stampato sulla console e registrato in una macro.
  • registrazione e editazione di macro.. I comandi Python generati quando l'utente manipola l'interfaccia possono essere registrati, modificati, e se necessario, salvati per essere poi riprodotti in seguito.
  • formato dei file composto (basato su ZIP). I documenti di FreeCAD vengono salvati con un'estensione .FCStd. Il documento può contenere molti tipi diversi di informazioni come la geometria, gli script o le icone delle miniature. Il file .FCStd è esso stesso un contenitore zip; un file di FreeCAD salvato è già stato compresso.
  • G.U.I. completamente personalizzabile. L'interfaccia di FreeCAD è basata su Qt ed è completamente configurabile tramite l'interprete Python. Oltre alle funzioni standard definite nel software, si ha a disposizione la potenze e la versatilità dell'intero framework Qt, il quale permette di aggiungere, spostare, agganciare oppure eliminare i widgets dall'area di lavoro.
  • creazione di miniature (per ora disponibile solo su piattaforme GNU/Linux). le icone dei documenti salvati in formato .fcstd forniscono una comoda anteprima del loro contenuto in molte applicazioni di gestione dei file, come Nautilus di Gnome, rendendo facile individuare i propri elaborati.
  • installatore MSI modulare. L'installatore di FreeCAD garantisce una installazione flessibile in ambienti Microsoft Windows®. Sono disponibili anche dei pacchetti specifici per Ubuntu.

Funzioni in fase di sviluppo

  • Feature-assembly.jpg
    Un modulo di Assemblaggio che permetta di lavorare contemporaneamente su diverse forme, documenti, file e relazioni...
Questo modulo è attualmente in fase di progettazione.


Ambienti complementari

Alcuni utenti esperti hanno creato vari ambienti complementari personalizzati.


Arrow-left.svg Informazioni su FreeCAD Pagina precedente:
Pagina successiva: Installazione su Windows Arrow-right.svg

Installazione


Arrow-left.svg Installazione Pagina precedente:
Pagina successiva: Installazione su Linux/Unix Arrow-right.svg

Il modo più semplice per installare FreeCAD su Windows è quello di scaricare uno degli installatori.

Windows.png Windows 32 bit (sha256)

Windows.png Windows 64 bit (sha256)


Dopo aver scaricato il file .msi (Microsoft Installer), fare doppio clic su di esso per avviare il processo di installazione automatica.

Più avanti sono riportate ulteriori informazioni sulle opzioni tecniche.
Se appaiono scoraggianti, nessuna preoccupazione, ignoratele! La maggior parte degli utenti Windows ha bisogno solo del file .msi per installare e iniziare ad usare FreeCAD!


Semplice installazione con Microsoft Installer

Il modo più semplice per installare FreeCAD su Windows è utilizzare il pacchetto di installazione scaricabile sopra. Questa pagina descrive l'utilizzo e le funzionalità di "Microsoft Installer" per ulteriori opzioni di installazione.

Se si desidera scaricare una versione di sviluppo (che potrebbe essere instabile), vedere la pagina Download.

Installazione da riga di comando

Con l'utilità a riga di comando msiexec.exe, sono disponibili funzionalità aggiuntive come l'installazione non interattiva e l'installazione amministrativa. Vedere sotto gli esempi.

Installazione non interattiva

L'installazione si avvia con il comando:

 msiexec /i FreeCAD<version>.msi

L'installazione può essere avviata a livello di programmazione. Ulteriori parametri possono essere passati alla fine della riga di comando, ad esempio:

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

Limitazione dell'interfaccia utente

Il livello di interfaccia visualizzabile dall'installatore può essere impostato con le opzioni /q

  • /qn - Senza interfaccia
  • /qb - Interfaccia di base - visualizza solo una finestra di dialogo di avanzamento con il pulsante Annulla
  • /qb! - Come /qb, ma nasconde il pulsante Annulla
  • /qr - Interfaccia ridotta - visualizza tutte le finestre di dialogo che non richiedono interazione da parte dell'utente (salta tutte le finestre modali)
  • /qn+ - Come /qn, ma visualizza la finestra "Completed" alla fine
  • /qb+ - Come /qb, ma visualizza la finestra "Completed" alla fine

Directory di destinazione

La proprietà TARGETDIR determina la directory principale di installazione di FreeCAD.

Ad esempio, si può specificare una diversa unità di installazione con

TARGETDIR=R:\FreeCAD25

La cartella di destinazione predefinita (TARGETDIR di default) è [WindowsVolume\Programm Files\]FreeCAD<version>.

Installazione per tutti gli utenti

Aggiungendo

ALLUSERS=1

si realizza una installazione usabile da tutti gli utenti. Per impostazione predefinita, un'installazione non interattiva (/i) rende il pacchetto utilizzabile solo dall'utente corrente (quello che esegue l'installazione); un'installazione interattiva presenta una finestra di dialogo che assume come valore predefinito "tutti gli utenti" se l'utente che esegue l'installazione ha i permessi necessari.

Selezione delle caratteristiche

Varie proprietà permettono la selezione delle funzioni da installare, reinstallare, o rimuovere.

Il set di funzioni dell'installatore di FreeCAD è:

  • DefaultFeature - Installa il software appropriato, più le librerie di base
  • Documentation - Installa la documentazione
  • Source code - Installa il codice sorgente
  • ... ToDo

Inoltre, ALL specifica (installa) tutte le funzioni.

Tutte le funzioni dipendono da DefaultFeature, quindi installando qualsiasi funzione si installano automaticamente anche le funzione di default.

Le seguenti proprietà controllano le operazioni di installazione o di rimozione:

  • ADDLOCAL - Elenco delle funzioni da installare sulla macchina locale.
  • REMOVE - Elenco delle funzioni da eliminare dalla macchina locale.
  • ADDDEFAULT - Elenco delle funzioni aggiunte nella loro configurazione di default (che è locale per tutte le funzioni di FreeCAD).
  • REINSTALL - Elenco delle funzioni da reinstallare o riparare.
  • ADVERTISE - Elenco delle funzioni per cui fornire un avviso di installazione.

Ci sono alcune altre proprietà aggiuntive disponibili, vedere la documentazione MSDN per i dettagli.

Con queste opzioni, aggiungendo

ADDLOCAL=Extensions

installa l'interprete e registra le estensioni, ma non installa niente altro.

Disinstallazione

Si può disinstallare FreeCAD con:

msiexec /x FreeCAD<version>.msi

Per la disinstallazione, non è necessario disporre del file MSI; in alternativa, può anche essere specificato il codice del pacchetto o del prodotto.

Per trovare il codice del prodotto, esplorare le proprietà del collegamento per la disinstallazione che FreeCAD installa nel menu di Avvio.

Installazione Amministrativa

Si può iniziare una installazione "amministrativa" (da rete) con:

msiexec /a FreeCAD<version>.msi

I file vengono decompressi nella directory di destinazione (che dovrebbe essere una directory in rete), ma non vengono apportate altre modifiche al sistema locale.

Inoltre, viene generato un altro file .msi (più piccolo) nella directory di destinazione, che i clienti possono utilizzare per eseguire un'installazione locale (le future versioni potrebbero anche offrire di mantenere alcune funzioni sull'unità di rete).

Attualmente non esiste alcuna interfaccia per le installazioni amministrative.

La directory di destinazione deve essere specificata nella riga di comando.

Non esiste una specifica procedura di disinstallazione, basta cancellare la directory di destinazione se non è più utilizzata da nessun client.

Con

msiexec /jm FreeCAD<version>.msi

è possibile, all'inizio, "annunciare" FreeCAD a una macchina (con /jm oppure ad un utente con /ju).

In questo modo, le icone appaiono nel menu Start e le estensioni vengono registrate senza che il software venga effettivamente installato.

Il primo uso di una funzione provoca l'installazione della funzione stessa.

L'installatore di FreeCAD attualmente supporta solo l'annuncio per le voci del menu di avvio, ma non supporta l'annuncio per i comandi di avvio veloce.

Installazione automatica su un gruppo di macchine

Utilizzando i criteri di gruppo di Windows, è possibile automatizzare l'installazione di FreeCAD su un gruppo di macchine.

Per effettuare questa operazione, attenersi alla seguente procedura:

  1. Accedere al controller di dominio.
  2. Copiare il file MSI in una cartella condivisa a cui è consentito l'accesso a tutti i computer di destinazione
  3. Aprire il componente MMC "Active Directory users and computers"
  4. Passare al gruppo di computer che necessitano di FreeCAD
  5. Aprire Proprietà
  6. Aprire Criteri di gruppo - Group Policies
  7. Aggiungere un nuovo criterio, e editarlo - new policy
  8. In Computer Configuration/Software Installation, sceglire New/Package
  9. Selezionare il file MSI attraverso il percorso di rete
  10. Facoltativamente, selezionare che si desidera che FreeCAD venga disinstallato se il computer lascia il campo di applicazione del criterio.

La propagazione dei criteri di gruppo richiede in genere un po 'di tempo - per distribuire in modo affidabile il pacchetto, tutte le macchine dovrebbero essere riavviate.

Installazione su Linux con Crossover Office

È possibile installare la versione Windows di FreeCAD su un sistema Linux utilizzando CXOffice 5.0.1.

Eseguire msiexec dalla riga di comando di CXOffice.

Supponendo che il pacchetto di installazione si trovi nella directory "software", nell'unità "Y:":

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


FreeCAD viene eseguito, ma è stato riferito che OpenGL non funziona, come succede con altri programmi che girano sotto [Wine], quali ad esempio [SketchUp].

Arrow-left.svg Installazione Pagina precedente:
Pagina successiva: Installazione su Linux/Unix Arrow-right.svg


Arrow-left.svg Installazione in Windows Pagina precedente:
Pagina successiva: Installazione in Mac Arrow-right.svg

L'installazione di FreeCAD sui sistemi Linux più noti ora è stata approvata dalla comunità e FreeCAD dovrebbe essere accessibile direttamente tramite il "Gestore dei pacchetti" disponibile nella propria distribuzione. Il team di FreeCAD fornisce inoltre i pacchetti "ufficiali" quando sono rilasciate le nuove versioni, e fornisce i repository sperimentali Personal Package Archive (PPA) per testare le ultime caratteristiche sviluppate.

Appena terminata l'installazione di FreeCAD, è ora di iniziare!

Ubuntu e sistemi basati su Ubuntu

Molte distribuzioni Linux sono basate su Ubuntu e condividono i suoi repository. Per altre varianti ufficiali (Kubuntu, Xubuntu e Lubuntu), ci sono distro non ufficiali come per Linux Mint, Voyager e altri. Le opzioni di installazione riportate in seguito dovrebbero essere compatibili con tali sistemi.

Repository ufficiale di Ubuntu

FreeCAD è disponibile nei repository di Ubuntu e può essere installato tramite il Centro Software o tramite il terminale con:

sudo apt-get install freecad

Importanti Note: E probabile che la versione installata in questo modo non sia aggiornata e non possieda le ultime caratteristiche. Per ottenere l'ultima versione rilasciata, si prega di utilizzare il (PPA).

Versione stabile da PPA tramite GUI

Per installare FreeCAD utilizzando il PPA dall'interfaccia grafica, si prega di seguire queste istruzioni. La comunità FreeCAD fornisce un PPA repository on Launchpad con l'ultima versione di FreeCAD stabile.

È necessario aggiungere alle Sorgenti software del sistema il seguente PPA. Per farlo aprire il Software Centre → Modifica Sorgenti → Software → Altro software. Fare clic su Aggiungi e copiare e incollare il codice sottostante:

ppa:freecad-maintainers/freecad-stable

Aggiornare le sorgenti del software, se richiesto. Ora, è possibile trovare ed installare l'ultima versione stabile di FreeCAD da Ubuntu Software Center.

Versione stabile da PPA tramite console

Digitare (o copia-incolla) questi comandi in una console per aggiungere il PPA e installare FreeCAD con la sua documentazione:

Per il PPA "stable"

sudo add-apt-repository ppa:freecad-maintainers/freecad-stable

Non dimenticare di recuperare l'elenco aggiornato dei pacchetti:

sudo apt-get update

Update sincronizza il proprio elenco dei pacchetti con quelli disponibili sul server.

Poi, installare FreeCAD con la sua documentazione:

sudo apt-get install freecad freecad-doc && sudo apt-get upgrade

Upgrade scarica e installa la versione più recente dei pacchetti dei programmi installati. Viene applicato a tutti i software installati sul computer.

Per avviare la versione stabile di FreeCAD eseguire questo comando:

freecad

Versione daily da PPA tramite console

Per installare l'ultima versione instabile di FreeCAD, utilizzare il PPA denominato "freecad-daily" repositorio PPA su Launchpad. In questo modo è possibile accedere alla versione più evoluta di FreeCAD. Questo PPA viene compilato automaticamente tutti i giorni dal ramo master del repositorio ufficiale di FreeCAD. Di solito contiene numerose correzioni di bug e gli ultimi aggiornamenti di funzionalità.

Per il PPA "daily"

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

You can then update to the latest daily at any time with:

sudo apt-get update
sudo apt-get install freecad-daily

Per avviare la versione daily build di FreeCAD eseguire questo comando:

freecad-daily

Debian e altri sistemi basati su Debian

A partire da Debian Lenny, FreeCAD è disponibile direttamente nei repository di software Debian e può essere installato tramite Synaptic o semplicemente con:

sudo apt-get install freecad

OpenSUSE

FreeCAD si installa normalmente con:

zypper install FreeCAD

Gentoo

FreeCAD si può costruire/installare semplicemente eseguendo:

emerge freecad

Fedora

FreeCAD has been included in the official Fedora packages since Fedora 20. It can be installed from the command line with:

sudo dnf install freecad

On older Fedora releases, that was:

sudo yum install freecad

The gui packages managers can also be used. Search for "freecad". The official release package version tends to be well behind the FreeCAD releases. Package: freecad shows the versions included in the Fedora repositories over time and versions.

More current versions can be obtained by downloading one of the .AppImage releases from the github repository. These work fine on Fedora.

If you want to keep up with the absolute latest daily builds, FreeCAD is also available on copr. To install the build from there, in a terminal session, enter:

sudo dnf copr enable @freecad/nightly
sudo dnf install freecad

That leaves the copr repository active, so

sudo dnf upgrade

or equivalent, will update to the latest FreeCAD build, along with updates from any of the other active repos. If you want something a bit more stable, you can disable @freecad/nightly again after the initial install. The copr repository only keeps builds from the past 2 weeks. This is not a solution if you want to pick a specific older version.

Instructions are also available on compile FreeCAD yourself, including a script specifically for Fedora. With a minor change, to checkout the specific commit from git, any version since about FreeCAD 0.15 can be built on any distribution since Fedora 21.

Arch

Installing FreeCAD on Arch Linux and derivatives (ex. Manjaro):

pacman -S freecad

Altri

Se scoprite che il vostro sistema è dotato di FreeCAD, ma in questa pagina non è documentato, per favore comunicatelo tramite il forum!

Sulla rete sono disponibili diversi pacchetti alternativi non ufficiali di FreeCAD, ad esempio per sistemi come Slackware o Fedora. Una ricerca in rete può dare rapidamente buoni risultati.

Installazione manuale in sistemi basati su .deb

Se per qualche motivo non è possibile utilizzare uno dei metodi di cui sopra, si può sempre scaricare uno dei pacchetti .deb disponibili nella pagina Download.
Linux.png Ubuntu 32/64bit AppImage-logo.png AppImage 64bit


Dopo aver scaricato la versione .deb corrispondente al proprio sistema, se è installato il pacchetto Gdebi (di solito lo è), basta spostarsi nella cartella del file scaricato e fare doppio clic su di esso. Le dipendenze necessarie sono installate automaticamente dal gestore del sistema. In alternativa è possibile installare il pacchetto dal terminale; spostarsi nella cartella che contiene il file e digitare:

sudo dpkg -i Name_of_your_FreeCAD_package.deb

sostituendo a Name_of_your_FreeCAD_package.deb il nome del file scaricato

Terminata l'installazione di FreeCAD, nella sezione "Grafica" del Menu Start viene aggiunta l'icona per avviarlo.

Installazione in altri sistemi Linux/Unix

Many common Linux distros now include a precompiled FreeCAD as part of the standard packages. This is often out of date, but is a place to start. Check the standard package managers for your system. One of the following (partial) list of commands could install the official version of FreeCAD for your distro from the terminal. These probably need administrator privileges.

apt-get install freecad
dnf install freecad
emerge freecad
slackpkg install freecad
yum install freecad
zypper install freecad

The package name is case sensitive, so try `FreeCAD` as well as `freecad`. If that does not work for you, either because your package manager does not have a precompiled FreeCAD version available, or because the available version is too old for your needs, you can try downloading one of the .AppImage releases from the github repository. These tend to work on most 64 bit Linux distributions, without any special installation. Just make sure the downloaded file is marked as executable, then run it.

Se ciò non basta, e non è possibile individuare un'altra fonte di un pacchetto precompilato per la propria situazione, è necessario compilare FreeCAD da soli.

Installare le versioni per Windows in Linux

Vedere la pagina Installazione in Windows.

Arrow-left.svg Installazione in Windows Pagina precedente:
Pagina successiva: Installazione in Mac Arrow-right.svg


Arrow-left.svg Installare in Unix/Linux Pagina precedente:
Pagina successiva: Per iniziare Arrow-right.svg

FreeCAD può essere installato su Mac OS X in una unica operazione usando l'installer seguente.

Mac.png MacOS 10.11 El Capitan 64-bit (sha256)


Questa pagina descrive l'uso e le caratteristiche del programma di installazione di FreeCAD. Essa comprende anche le istruzioni di disinstallazione.

Terminata l'installazione, è possibile iniziare!

Installazione semplice

L'installatore di FreeCAD viene fornito come pacchetto di installazione (.app) incluso in un file di immagine disco.

È possibile scaricare l'ultima versione dell'installatore dalla pagina Download. Dopo aver scaricato il file, basta montare l'immagine, poi trascinarla nella cartella Applicazioni o in una cartella a scelta..

Mac installer 1.png

Questo è tutto. Basta cliccare sulla app per lanciare FreeCAD. Se si riceve il messaggio "FreeCAD non può essere aperto in quanto proviene da uno sviluppatore non identificato", aprire la cartella (Applicazione) e fare clic destro sulla App quindi fare clic su apri e accettare di aprire l'applicazione.


Disinstallazione

Attualmente non c'è un programma di disinstallazione per FreeCAD. Per rimuovere completamente FreeCAD e tutti i componenti installati, trascinare i seguenti file e cartelle nel cestino:

  • In /Applications:
    • FreeCAD

Tutto qui.

Arrow-left.svg Installare in Unix/Linux Pagina precedente:
Pagina successiva: Per iniziare Arrow-right.svg

Informazioni su FreeCAD

Arrow-left.svg Installazione su Mac Pagina precedente:
Pagina successiva: Navigazione 3D - Tipo di mouse Arrow-right.svg

Prefazione

FreeCAD è una applicazione per la modellazione parametrica di tipo CAD/CAE. È fatto principalmente per la progettazione meccanica, ma serve anche in tutti casi in cui è necessario modellare degli oggetti 3D con precisione e avere il controllo dello storico della modellazione.

Nonostante FreeCAD sia ancora nella fase iniziale del suo sviluppo, offre già un lunga lista (che continua a aumentare) di funzionalità, ma ne mancano ancora molte altre, specialmente rispetto alle soluzioni commerciali, quindi potreste ritenerlo non ancora abbastanza sviluppato per essere usato in ambito produttivo. C'è una comunità in rapida crescita di utenti entusiasti, e si possono già trovare molti esempi di progetti di qualità sviluppati con FreeCAD.

Come tutti i progetti open-source, il progetto FreeCAD non è un lavoro a senso unico che gli sviluppatori vi consegnano. La crescita del progetto, l'acquisizione di nuove funzionalità e la stabilità dell'applicazione (la correzione dei bug) dipendono molto dalla sua comunità. Quindi non dimenticate questo quando iniziate ad utilizzare FreeCAD, e se vi piace, potete contribuire e aiutare il progetto!

Installazione

Per iniziare è necessario scaricare ed installare FreeCAD. Consultare la pagina (Download/en) Download/it per ottenere informazioni sulla versione corrente e sugli ultimi aggiornamenti. Sono disponibili i file di installazione per Windows (.msi), Ubuntu & Debian (.deb), openSUSE (.rpm) e Mac OSX. FreeCAD è disponibile per l'installazione dai gestori di pacchetti di molte altre distribuzioni Linux. È anche disponibile un eseguibile indipendente [1], che viene eseguito sui più recenti sistemi Linux a 64 bit Dato che FreeCAD è open-source, se siete avventurosi e volete vedere le ultime funzionalità che in questo momento sono in fase di sviluppo, potete anche prelevare il codice sorgente e compilarlo (en).

Esplorare FreeCAD

Freecad-interface.jpg
  1. La vista 3D che visualizza gli oggetti contenuti nel documento
  2. La vista ad albero che mostra la gerarchia e lo storico della costruzione di tutti gli oggetti del documento
  3. L'editore delle proprietà che consente di visualizzare e modificare le proprietà degli oggetti selezionati
  4. La finestra dei rapporti dove FreeCAD stampa i messaggi di avvisi o di errori
  5. La console python dove sono visibili tutti i comandi eseguiti da FreeCAD, e in cui è possibile inserire il codice python
  6. Il selettore degli Ambienti che mostra quello attivo

Il concetto principale è che, dietro la sua interfaccia, FreeCAD è suddiviso in ambienti di lavoro. Ogni ambiente raggruppa gli strumenti idonei a svolgere un compito specifico, come ad esempio lavorare con gli oggetti mesh, oppure disegnare oggetti 2D o schizzi vincolati. È possibile cambiare l'ambiente corrente con il selettore (6). Si può personalizzare il set di strumenti inclusi in ogni ambiente, aggiungere degli strumenti da altri ambienti o anche aggiungere strumenti di propria creazione, che noi chiamiamo macro. Punti di partenza ampiamente utilizzati sono PartDesign e Part.

Al primo avvio di FreeCAD viene visualizzato lo start center. Ecco come appare nella versione 0.16:

Startcenter.jpg

Per FreeCAD 0.17 vedere questo screenshot start center.


Lo Start Center permette di passare rapidamente a uno degli ambienti di lavoro più comuni, di aprire uno dei file recenti, oppure di vedere le ultime novità dal mondo di FreeCAD. Nelle preferenze è possibile modificare l'ambiente di lavoro predefinito.

Navigare nello spazio 3D

FreeCAD permette di interagire con lo spazio 3D in diverse modalità di navigazione selezionabili nel dialogo delle preferenze oppure cliccando con il tasto destro nella vista 3D. Uno di essi è specifico per la Navigazione Touchpad, dove non si usa il tasto centrale del mouse.

Per la modalità di default, la "Navigazione CAD", i comandi sono i seguenti:

Selezione Traslazione Zoom Rotazione vista
Primo metodo
Rotazione vista
Secondo metodo
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png Rotate cursor.png
Mouse LMB.svg Mouse MMB hold.svg Mouse MMB rotate.svg Mouse MMB+LMB hold.svg Mouse MMB+RMB hold.svg
Premere il tasto sinistro del mouse su un oggetto che si desidera selezionare.

Tenendo premuto Ctrl consente la selezione di più oggetti.

Tenere premuto il pulsante centrale del mouse, quindi spostare il puntatore. Usare la rotellina del mouse per zoommare avanti e indietro.

Facendo clic sul pulsante centrale del mouse, la vista viene nuovamente centrata sulla posizione del cursore.

Tenere premuto il pulsante centrale del mouse, quindi premere e tenere premuto il pulsante sinistro del mouse, quindi spostare il puntatore.

La posizione del cursore quando viene premuto il pulsante centrale del mouse determina il centro di rotazione. La rotazione funziona come una palla che ruota attorno al suo centro. Se i pulsanti vengono rilasciati prima di interrompere il movimento del mouse, la visualizzazione continua la rotazione, se l'azione è abilitata.

Un doppio clic con il pulsante centrale del mouse imposta un nuovo centro di rotazione.

Tenere premuto il pulsante centrale del mouse, e tenere premuto il pulsante destro del mouse, quindi spostare il puntatore.

Con questo metodo il pulsante centrale del mouse può essere rilasciato dopo aver tenuto premuto il pulsante destro del mouse.

Gli utenti che utilizzano il mouse con la mano destra potrebbero trovare questo metodo più semplice del primo metodo.

Ctrl+Mouse RMB.svg Ctrl+Shift+Mouse RMB.svg Shift+Mouse RMB.svg
Modalità Traslazione: tenere premuto il tasto Ctrl, preme il tasto destro del mouse una volta, quindi muovere il puntatore. Disponibile dalla versione 0.17 Modalità zoom: tenere premuti i tasti Ctrl e Shift, premere il pulsante destro del mouse una volta, quindi spostare il puntatore. Disponibile dalla versione 0.17 Modalità rotazione: tenere premuto il tasto Shift, premere il tasto destro del mouse una volta, quindi spostare il puntatore. Disponibile dalla versione 0.17


Inoltre, sono disponibili alcune viste preconfigurate (dall'alto, laterale, frontale, ecc) accessibili dal menu Visualizza → Viste standard oppure tramite i pratici comandi veloci dei tasti numerici ( 1, 2, 3 etc...). Facendo clic con il pulsante destro su un oggetto o un'area vuota della vista 3D, si ha accesso rapido ad alcune operazioni comuni, come l'impostazione di una vista particolare, o l'individuazione di un oggetto nella vista ad albero.

Primi passi con FreeCAD

L'obiettivo di FreeCAD è quello di consentire di creare dei modelli 3D di alta precisione mantenendo uno stretto controllo sui modelli per essere in grado di tornare indietro nello storico della modellazione e di variare i parametri, e alla fine di costruire quei modelli (attraverso la stampa 3D, CNC o anche la costruzione in cantiere). È quindi molto diverso da alcune applicazioni 3D realizzate per altri scopi, come ad esempio per i film di animazione o per i giochi. La sua curva di apprendimento può essere ripida, specialmente se questo è il primo contatto con la modellazione 3D. Quando si rimane bloccati in un certo punto, ricordarsi che nel FreeCAD forum c'è una comunità amichevole di utenti può essere in grado di fornire un aiuto in breve tempo.

L'ambiente di lavoro con cui iniziare a lavorare in FreeCAD dipende dal tipo di lavoro si intende realizzare. Quando si ha intenzione di lavorare su modelli meccanici, o più in generale su qualsiasi oggetto di piccole dimensioni, probabilmente si vuole provare Part Design. Se si lavora in 2D, allora conviene passare all'ambiente Draft, o all'ambiente Sketcher quando servono i vincoli. Se si vuole fare BIM, avviare l'ambiente Architettura. Se si lavora con il disegno navale, è disponibile uno speciale ambiente Ship. Se si proviene dal mondo di OpenSCAD, si può provare l'ambiente OpenSCAD.

È possibile commutare gli ambienti di lavoro in qualsiasi momento, e anche personalizzare il proprio ambiente preferito aggiungendovi degli strumenti di altri ambienti.

Lavorare con gli ambienti PartDesign e Sketcher

PartDesign è fatto appositamente per costruire oggetti complessi, partendo da forme semplici a cui aggiungere o rimuovere dei pezzi (chiamate "funzioni"), fino a ottenere l'oggetto finale. Tutte le caratteristiche applicate durante il processo di modellazione vengono memorizzate in una vista separata denominata vista a albero, che contiene anche gli altri oggetti del documento. Si può pensare ad un oggetto di PartDesign come a una successione di operazioni, ciascuna applicata al risultato di quella precedente, formando una grande catena. Nella vista ad albero, si vede l'oggetto finale, ma è possibile espanderla e recuperare tutti gli stati precedenti, e modificare i loro parametri, questo aggiorna automaticamente l'oggetto finale.

L'ambiente PartDesign fa uso importante di un altro ambiente, l'ambiente Sketcher. Sketcher permette di disegnare forme 2D vincolate, il che significa che alcune parti della forma 2D possono avere dei vincoli. Ad esempio, è possibile disegnare un rettangolo e impostare un vincolo di lunghezza per uno dei suoi lati. Quel lato quindi non può più essere ridimensionato, fino a quando il vincolo non viene modificato.

Queste forme 2D realizzate con lo sketcher sono molto utilizzate in PartDesign, ad esempio per creare i volumi 3D o per disegnare le aree sulle facce dell'oggetto che devono essere scavate dal volume principale. Ecco un tipico flusso di lavoro PartDesign:

  1. Creare un nuovo schizzo
  2. Disegnare un contorno chiuso (assicurarsi che tutti i punti sono uniti)
  3. Chiudere lo schizzo
  4. Espandere lo schizzo in un solido 3D con lo strumento Pad
  5. Selezionare una faccia del solido
  6. Creare un secondo schizzo (questa volta sarà disegnato sulla faccia selezionata)
  7. Disegnare una forma chiusa
  8. Chiudere lo schizzo
  9. Creare uno scavo con il secondo schizzo, sul primo oggetto

Si ottiene un oggetto simile a questo:

Partdesign example.jpg

In qualsiasi momento è possibile selezionare gli schizzi originali e modificarli oppure modificare i parametri delle operazioni di estrusione o di scavo, l'oggetto finale viene automaticamente aggiornato.

Lavorare con gli ambienti Draft e Arch

Gli ambienti Draft e Arch si comportano in modo un po' diverso dagli altri ambienti di lavoro di cui sopra, anche se seguono le regole comuni di FreeCAD. In breve, Sketcher e PartDesign sono utilizzati principalmente per la progettazione di singoli pezzi, invece Draft e Arch sono concepiti per facilitare il lavoro quando si opera con diversi oggetti semplici.

L'ambiente Draft offre degli strumenti 2D in parte simili a quelli che si possono trovare nelle applicazioni tradizionali di CAD 2D quali AutoCAD. Però, il disegno 2D è lontano dagli scopi di FreeCAD, quindi non aspettatevi di trovare in esso la gamma completa di strumenti offerta da queste applicazioni dedicate. La maggior parte degli strumenti di Draft lavorano, non solo in un piano 2D, ma anche nello spazio 3D, e beneficiano degli speciali sistemi di supporto come il Piano di lavoro e lo Snapping.

L'ambiente Arch aggiunge a FreeCAD gli strumenti BIM che consentono di costruire i modelli architettonici con degli oggetti parametrici. L'ambiente Arch si basa ampiamente sugli altri moduli come Draft e Sketcher. Tutti gli strumenti di Draft sono presenti anche nell'ambiente Arch e molti strumenti di Arch usano i sistemi di supporto di Draft.

Un tipico flusso di lavoro con gli ambienti Arch e Draft potrebbe essere:

  1. Disegnare un paio di linee con lo strumento Linea di Draft
  2. Selezionare tutte le linee e premere lo strumento Muro per costruire un muro su ciascuna di esse
  3. Unire le pareti selezionandole e premendo lo strumento Aggiungi di Draft
  4. Creare un oggetto Piano, e posizionare in esso i Muri lavorando nella Vista ad albero
  5. Creare un oggetto Edificio, e posizionare in esso il Piano lavorando nella Vista ad albero
  6. Creare una Finestra cliccando sullo strumento Finestra, selezionare un modello predefinito nel suo pannello, quindi fare clic su una faccia di un muro
  7. Aggiungere le Quote impostando prima il piano di lavoro, se necessario, quindi utilizzando lo strumento Dimension di Draft

Si ottiene un oggetto simile a questo:

Arch workflow example.jpg

Maggiori informazioni si trovano nella sezione Tutorial.

Script

Infine, una delle più potenti caratteristiche di FreeCAD che è l'ambiente di script. Dalla console Python integrata (o tramite qualsiasi altro script Python esterno), è possibile accedere a quasi tutte le parti di FreeCAD, creare o modificare le geometrie, modificare la rappresentazione degli oggetti nella vista 3D, oppure accedere e modificare l'interfaccia di FreeCAD. Gli script Python possono essere utilizzati anche all'interno delle macro che forniscono un metodo facile e veloce per creare combinazioni di comandi personalizzati.

Aggiornamenti

Arrow-left.svg Installazione su Mac Pagina precedente:
Pagina successiva: Navigazione 3D - Tipo di mouse Arrow-right.svg

Lavorare con FreeCAD

Arrow-left.svg Per iniziare Pagina precedente:
Pagina successiva: Cubo di navigazione Arrow-right.svg

La funzione Navigazione 3D - Tipo di mouse di FreeCAD comprende i comandi utilizzati per navigare visivamente lo spazio 3D e per interagire con gli oggetti visualizzati. Attualmente FreeCAD offre diversi stili di navigazione con il mouse. Lo stile di navigazione predefinito, denominato "Navigazione CAD​​", è molto semplice e pratico, ma si può anche usare uno stile alternativo, secondo le proprie preferenze.

Navigazione

I gesti del mouse utilizzati per la manipolazione dell'oggetto variano in base allo stile di navigazione selezionato; lo stile attivo, attualmente selezionato, viene utilizzato in tutti gli ambienti.

Ci sono due modi per modificare lo stile di navigazione:

  • In Preferenze, Modifica → Preferenze → Visualizzazione → Vista 3D → Navigazione 3D.
  • Cliccare col tasto destro nello spazio vuoto dell'area di visualizzazione 3D, quindi selezionare Stile di navigazione →... nel menu contestuale.

Navigazione CAD

Questo è lo stile di navigazione predefinito. Permette all'utente un semplice controllo della vista. Richiede l'uso della tastiera solo per eseguire multi-selezioni.

Selezione Traslazione Zoom Rotazione vista
Primo metodo
Rotazione vista
Metodo alternativo
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png Rotate cursor.png
Mouse LMB.svg Mouse MMB hold.svg Mouse MMB rotate.svg Mouse MMB+LMB hold.svg Mouse MMB+RMB hold.svg
Premere il tasto sinistro del mouse su un oggetto che si desidera selezionare.

Tenendo premuto Ctrl consente la selezione di più oggetti.

Tenere premuto il pulsante centrale del mouse, quindi spostare il puntatore. Usare la rotellina del mouse per zoommare avanti e indietro.

Facendo clic sul pulsante centrale del mouse, la vista viene nuovamente centrata sulla posizione del cursore.

Tenere premuto il pulsante centrale del mouse, quindi premere e tenere premuto il pulsante sinistro del mouse, quindi spostare il puntatore.

La posizione del cursore quando viene premuto il pulsante centrale del mouse determina il centro di rotazione. La rotazione funziona come una palla che ruota attorno al suo centro. Se i pulsanti vengono rilasciati prima di interrompere il movimento del mouse, la visualizzazione continua la rotazione, se l'azione è abilitata.

Un doppio clic con il pulsante centrale del mouse imposta un nuovo centro di rotazione.

Tenere premuto il pulsante centrale del mouse, e tenere premuto il pulsante destro del mouse, quindi spostare il puntatore.

Con questo metodo il pulsante centrale del mouse può essere rilasciato dopo aver tenuto premuto il pulsante destro del mouse.

Gli utenti che utilizzano il mouse con la mano destra potrebbero trovare questo metodo più semplice del primo metodo.

Ctrl+Mouse RMB.svg Ctrl+Shift+Mouse RMB.svg Shift+Mouse RMB.svg
Modalità Traslazione: tenere premuto il tasto Ctrl, preme il tasto destro del mouse una volta, quindi muovere il puntatore. Disponibile dalla versione 0.17 Modalità zoom: tenere premuti i tasti Ctrl e Shift, premere il pulsante destro del mouse una volta, quindi spostare il puntatore. Disponibile dalla versione 0.17 Modalità rotazione: tenere premuto il tasto Shift, premere il tasto destro del mouse una volta, quindi spostare il puntatore. Disponibile dalla versione 0.17


Navigazione OpenInventor

La Navigazione OpenInventor (formalmente Inventor), si basa sul modello Open Inventor. Per selezionare gli oggetti, è necessario tenere premuto il tasto Ctrl.

Questa modalità non è basata su Autodesk Inventor.

Selezione Traslazione Zoom Rotazione vista
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Ctrl+Mouse LMB.svg Mouse MMB hold.svg Mouse MMB rotate.svg Mouse MMB+LMB hold.svg Mouse LMB hold.svg
Tenere premuto Ctrl, quindi premere il tasto sinistro del mouse sopra un oggetto che si desidera selezionare. Tenere premuto il pulsante centrale del mouse, quindi spostare il puntatore. Usare la rotellina del mouse per zoommare avanti e indietro.

In alternativa, tenere premuto il pulsante centrale del mouse, quindi premere e tenere premuto il pulsante sinistro del mouse, quindi spostare il puntatore.

Tenere premuto il pulsante sinistro del mouse, quindi spostare il puntatore.


Navigazione Blender

Lo stile di navigazione Blender segue il modello di Blender. In precedenza non c'era la traslazione con il solo mouse, ed era richiesto l'uso del tasto Shift per spostare la vista. Questo è cambiato nel 2016 con l'introduzione di una funzione aggiuntiva. Per eseguire una panoramica della vista, ora è possibile premere i pulsanti sinistro e destro del mouse per spostare la vista.

Selezione Traslazione Zoom Rotazione vista
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Mouse LMB.svg Shift+Mouse MMB hold.svg Mouse LMB+RMB hold.svg Mouse MMB rotate.svg Mouse MMB hold.svg
Premere il tasto sinistro del mouse su un oggetto che si desidera selezionare. Tenere premuto Shift e il pulsante centrale del mouse, quindi spostare il puntatore.

In alternativa, tenere premuti i pulsanti sinistro e destro del mouse, quindi spostare il puntatore.

Usare la rotellina del mouse per zoommare avanti e indietro. Tenere premuto il pulsante centrale del mouse, quindi spostare il puntatore.


Navigazione Touchpad

Nella navigazione Touchpad, traslazione, zoom e rotazione della vista richiedono un tasto modificatore insieme al touchpad.

Selezione Traslazione Zoom Rotazione vista
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Touchpad LB.svg Shift+Touchpad.svg PagSù, PagGiù Alt+Touchpad.svg
Premere il tasto sinistro del mouse su un oggetto che si desidera selezionare. Hold Shift, quindi spostare il puntatore. Use PagSù e PagGiù per ingrandire e ridurre. Tenere premuto Alt, quindi spostare il puntatore.
Shift+Ctrl+Touchpad.svg Shift+Touchpad LB hold.svg
In alternativa, tenere premuto Shift e Ctrl, quindi spostare il puntatore. In alternativa, tenere premuto Shift e il pulsante sinistro, quindi spostare il puntatore.


Navigazione Gesture

Questo stile di navigazione è stato introdotto nella versione 0.16, è fatto su misura per essere usato con il touchscreen o con la penna, ma è usabile anche con il mouse.

Selezione Traslazione Zoom Rotazione vista Inclinazione vista
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png Rotate cursor.png
Mouse LMB.svg Mouse RMB hold.svg Mouse MMB rotate.svg Mouse LMB hold.svg Mouse LMB+RMB hold.svg
Premere il tasto sinistro del mouse su un oggetto che si desidera selezionare. Tenere premuto il tasto destro del mouse, quindi spostare il puntatore. Usare la rotellina del mouse per zoommare avanti e indietro. Tenere premuto il pulsante sinistro del mouse, quindi spostare il puntatore.

In Sketcher e altre modalità di modifica, questo comportamento è disabilitato. Tenere premuto Alt quando si preme il pulsante del mouse per accedere alla modalità di rotazione.

Per impostare il punto di messa a fuoco della fotocamera per la rotazione, fare clic su un punto con il pulsante centrale del mouse. In alternativa, puntare il cursore su un punto e premere H sulla tastiera.

Tenere premuti i pulsanti sinistro e destro del mouse, quindi spostare il puntatore di lato.
Touch Tap.svg Touch Two-Finger-Drag.svg Touch Tap-Hold-Drag.svg Touch Pinch.svg Touch One-Finger-Drag.svg Touch Rotate.svg
Toccare per selezionare. Trascinare con due dita.

In alternativa, toccare e tenere premuto, quindi trascinare. Questo simula la traslazione con il tasto destro del mouse.

Trascinare due dita (pizzicare) più vicino o più lontano. Trascinare con un dito per ruotare.

Tenere premuto Alt quando ci si trova in Sketcher.

Ruota la linea immaginaria formata da due punti di contatto.

In v0.18 questo metodo è disabilitato per impostazione predefinita. Per abilitarlo, andare in Modifica → Preferenze → Visualizzazione e deselezionare la casella di controllo "Disabilita l'inclinazione touchscreen".


Navigazione Maya-Gesture

Nella navigazione Maya-Gesture, traslazione, zoom e rotazione della vista richiedono il tasto Alt insieme al pulsante del mouse; pertanto, è richiesto un mouse a tre pulsanti. È anche possibile usare i gesti poiché questa modalità è stata sviluppata sulla modalità Navigazione gestuale.

Selezione Traslazione Zoom Rotazione vista
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Mouse LMB.svg Alt+Mouse MMB hold.svg Alt+Mouse RMB hold.svg Mouse MMB rotate.svg Alt+Mouse LMB hold.svg
Premere il tasto sinistro del mouse su un oggetto che si desidera selezionare. Tenere premuto Alt e il pulsante centrale del mouse, quindi spostare il puntatore. Tenere premuto Alt e il tasto destro del mouse, quindi spostare il puntatore.

In alternativa, utilizzare la rotellina del mouse per ingrandire e ridurre.

Tenere premuto Alt e il tasto sinistro del mouse, quindi spostare il puntatore.


Navigazione Revit

Questo stile è stato introdotto nella versione 0.18.

Selezione Traslazione Zoom Rotazione vista
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Mouse LMB.svg Mouse MMB hold.svg Mouse LMB+RMB hold.svg Mouse MMB rotate.svg Shift+Mouse MMB hold.svg Mouse MMB+RMB hold.svg


Premere il tasto sinistro del mouse su un oggetto che si desidera selezionare. Tenere premuto il pulsante centrale del mouse, quindi spostare il puntatore.

In alternativa, tenere premuti i pulsanti sinistro e destro del mouse, quindi spostare il puntatore.

Usa la rotellina del mouse per zoommare avanti e indietro. Tenere premuto Shift e il pulsante centrale del mouse, quindi spostare il puntatore.

In alternativa, tenere premuto il pulsante centrale del mouse, e tenere premuto il pulsante destro del mouse, quindi spostare il puntatore.


OpenCascade

Questo stile è stato introdotto nella versione 0.18.

Selezione Traslazione Zoom Rotazione vista
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Mouse LMB.svg Ctrl+Mouse MMB hold.svg Mouse MMB hold.svg Mouse MMB rotate.svg Ctrl+Mouse LMB hold.svg Ctrl+Mouse RMB hold.svg


Premere il tasto sinistro del mouse su un oggetto che si desidera selezionare. Tenere premuto il pulsante centrale del mouse, quindi spostare il puntatore. Usare la rotellina del mouse per zoommare avanti e indietro.

In alternativa, tenere premuto Ctrl e il tasto sinistro del mouse, quindi spostare il puntatore.

Tenere premuto Ctrl e il tasto destro del mouse, quindi spostare il puntatore.


La selezione degli oggetti

Selezione semplice

Gli oggetti si possono selezionare con un click del tasto sinistro del mouse o facendo clic sull'oggetto nella vista 3D o selezionandoli nella vista ad albero.

Preselezione

Passando con il mouse sugli oggetti, una funzione di Preselezione li evidenzia e visualizza le relative informazioni prima della loro selezione. Se questo comportamento non è gradito o si dispone di una macchina lenta, è possibile disattivare la funzione nel dialogo delle preferenze.

La manipolazione degli oggetti

FreeCAD offre strumenti Manipolatori utilizzabili per modificare un oggetto o il suo aspetto visivo.

Un esempio semplice è dato dal Piano di taglio attivabile con il menu Visualizza → Piano di taglio.

Supporto Hardware

FreeCAD supporta anche i dispositivi di input 3D.

Problemi con Mac OS X

Recentemente abbiamo ricevuto segnalazioni nel forum da utenti Mac che questi pulsanti del mouse e le combinazioni di tasti non funzionano come previsto. Purtroppo, nessuno degli sviluppatori possiede un Mac e neppure gli altri collaboratori regolari. Abbiamo bisogno del vostro aiuto per determinare quali pulsanti del mouse e quali combinazioni di tasti funzionano e poter aggiornare questo wiki.

Arrow-left.svg Per iniziare Pagina precedente:
Pagina successiva: Cubo di navigazione Arrow-right.svg

I documenti di FreeCAD

Arrow-left.svg Navigazione 3D Pagina precedente:
Pagina successiva: Preferenze Arrow-right.svg
Screenshot treeview.jpg

Un documento FreeCAD contiene tutti gli oggetti della scena. Può contenere i gruppi e gli oggetti realizzati con qualsiasi ambiente di lavoro. Si possono quindi alternare gli ambienti pur continuando a lavorare sullo stesso documento. Il documento è ciò che viene salvato sul disco quando si salva il proprio lavoro. Inoltre, in FreeCAD è possibile aprire più documenti contemporaneamente, e aprire diverse viste dello stesso documento.

All'interno del documento, gli oggetti possono essere raggruppati, e avere un unico nome. La gestione dei gruppi, degli oggetti e dei nomi degli oggetti avviene prevalentemente nella vista a albero. Naturalmente, queste operazioni, come tutto in FreeCAD, si possono eseguire anche tramite interprete Python.

Nella vista ad albero, è possibile creare gruppi, spostare gruppi di oggetti, eliminare oggetti o gruppi, facendo clic destro nella vista ad albero o su un oggetto, oppure rinominare gli oggetti facendo doppio clic sui loro nomi, o eventualmente eseguire altre operazioni, attinenti l'ambiente di lavoro attivo.

Un documento FreeCAD può contenere oggetti di diversi tipi. Ogni ambiente di lavoro crea oggetti di tipo specifico, per esempio Ambiente Mesh crea oggetti Mesh , Ambiente Parte crea oggetti Parte, Ambiente Draft crea disegni e anche oggetti Parte, ecc.

In FreeCAD può essere attivo un solo documento alla volta. Il documento attivo è quello che viene visualizzato nella vista 3D corrente ed è il documento in lavorazione.

Applicazione e Interfaccia utente

Come per quasi tutto il resto, in FreeCAD, la parte interfaccia grafica utente (GUI) è separata dalla parte applicazione (App). Questo vale anche per i documenti.

I documenti sono composti da due parti: il documento Applicazione, che contiene gli oggetti, e il documento Visualizzazione, che contiene la rappresentazione degli oggetti sullo schermo.

Pensate a due spazi in cui sono definiti gli oggetti. I loro parametri costruttivi (si tratta di un cubo? di un cono? quanto misura?) sono memorizzati nel documento Applicazione, mentre la loro rappresentazione grafica (è disegnata con linee nere? con le facce blu?) sono memorizzati nel documento Visualizzazione. Questo permette di utilizzare FreeCAD anche senza interfaccia grafica, ad esempio all'interno di altri programmi, e di manipolare gli oggetti, anche senza disegnare nulla sullo schermo.

Il documento Visualizzazione contiene anche le viste 3D. Un documento può avere contemporaneamente diverse viste aperte, in modo da poterlo controllare da diversi punti di vista. Ad esempio, si può visualizzare allo stesso tempo una vista dall'alto e una vista frontale. Tutte le viste dello stesso progetto vengono memorizzate nel documento Visualizzazione. La produzione di nuove viste o la chiusura di viste attive si può fare dal menu Visualizza o facendo clic destro su una scheda di visualizzazione.

Script

Tramite l'interprete Python, si può facilmente accedere, creare o modificare i documenti. Ad esempio:

FreeCAD.ActiveDocument

Restituisce il documento corrente (attivo)

FreeCAD.ActiveDocument.Blob

Accede ad un oggetto chiamato "Blob" all'interno del documento

FreeCADGui.ActiveDocument

Restituisce il documento associato al documento corrente

FreeCADGui.ActiveDocument.Blob

Accede alla rappresentazione grafica (visualizza) l'oggetto "Blob"

FreeCADGui.ActiveDocument.ActiveView

Restituisce la vista corrente

Arrow-left.svg Navigazione 3D Pagina precedente:
Pagina successiva: Preferenze Arrow-right.svg


Arrow-left.svg Struttura dei file di FreeCad Pagina precedente:
Pagina successiva: Personalizzare l'interfaccia Arrow-right.svg

Il sistema delle preferenze di FreeCAD si trova nel menu Modifica → Preferenze.

Le funzionalità di FreeCAD sono suddivise in moduli separati, ciascun modulo si occupa della lavorazione in uno specifico Ambiente. FreeCAD utilizza il caricamento tardivo (late loading), questo significa che i componenti vengono caricati solo quando sono necessari. Come si può notare, un ambiente di lavoro con tutti i suoi componenti viene caricato solo al momento in cui l'ambiente viene selezionato nella barra degli strumenti di FreeCAD. Questo vale anche per le impostazioni delle preferenze (ndt le preferenze sono trattate come un componente dell'ambiente).

Senza alcun modulo caricato, si ha accesso a due sezioni di configurazione, responsabili delle impostazioni generali dell'applicazione e delle impostazioni della visualizzazione. Quando ci si trova in un certo ambiente, le preferenze di questo ambiente appaiono come nuove sezioni ed i formati di file supportati dall'ambiente sono visualizzati come nuova scheda nella sezione Importazione-Esportazione.

Facendo clic sul pulsante Reset nell'angolo in basso a sinistra di qualsiasi visualizzazione delle preferenze, tutte le preferenze di FreeCAD vengono reimpostate sui valori predefiniti.

Impostazioni generali

Questa sezione delle preferenze ha 6 schede:

Generale

Nella scheda Generale si può specificare quanto segue:

Nome Descrizione
Cambia lingua Seleziona la lingua dell'interfaccia utente di FreeCAD
Dimensione della lista dei file recenti

Specifica quanti file devono essere elencati nella lista dei file recenti
Abilita lo sfondo a mosaico Se selezionato, lo sfondo della finestra principale di FreeCAD sarà composto per default da piastrelle di questa immagine: Background.png
Questa opzione ha effetto solo se in Foglio di stile è selezionato Nessun foglio di stile.
L'immagine può essere cambiata aggiungendo le cartelle Gui/Images nella cartella
%APPDATA%/FreeCAD (su Windows),
$HOME/.FreeCAD (su Linux) o
$HOME/Library/Preferences/FreeCAD (su MacOS).
Inserire un file chiamato background.png e disattivare o attivare questo opzione per vedere il file modificato.
Foglio di stile Selezione di un foglio di stile. I fogli di stile definiscono l'aspetto dell'interfaccia utente di FreeCAD.
Dimensione dele icone della brra degli strumenti Selezione della dimensione per le icone della barra degli strumenti
Modulo da caricare automaticamente dopo l'avvio Selezione di quale ambiente verrà utilizzato direttamente dopo l'avvio di FreeCAD
Abilita la schermata iniziale all'avvio Se selezionato, all'avvio viene visualizzata la schermata iniziale di FreeCAD.
L'immagine della schermata iniziale può essere modificata aggiungendo le cartelle Gui/Images nella cartella %APPDATA%/FreeCAD (dove %APPDATA% è la cartella dell'applicazione specifica dell'utente di FreeCAD nel proprio sistema operativo). Inserire un file chiamato splash_image.png e riavviare FreeCAD per vedere la schermata iniziale modificata.
Abilita il ritorno a capo automatico I testi vanno a capo automaticamente quando superano lo spazio orizzontale disponibile nella console Python. Questa console è visualizzabile usando il menu Visualizza → Pannelli → Console Python.
Preference General Tab 01.png


Documento

Nella scheda Documento si può specificare quanto segue:

Nome Descrizione
Crea un nuovo documento all'avvio Se selezionato, FreeCAD crea un nuovo documento quando viene avviato
Livello di compressione di salvataggio del documento Specifica del livello di compressione per i file FCStd. I file FCStd sono file compressi ZIP. Quindi puoi rinominare il loro suffisso .FCStd in .zip e aprirli con un programma di archivio ZIP.
Utlizza Annulla/Ripristina sui documenti Se selezionato, tutti i cambiamenti nei documenti sono memorizzati in modo che possano essere annullati o ripristinati
Massimo numero di passaggi Annulla/Ripristina Specifica quanti passaggi Annulla/Ripristina devono essere registrati
Esegui il salvataggio automatico all'avvio Se è disponibile un file di ripristino FreeCAD esegue automaticamente un ripristino del file all'avvio. In questo modo è possibile ripristinare i file in caso di arresto anomalo.
Salva le informazioni di autorecupero ogni Specifica la frequenza con cui viene scritto un file di ripristino.
Salva la miniatura nel file del progetto al salvataggio del documento Se selezionato, quando il documento viene salvato viene salvata anche una miniatura. Ad esempio, la miniatura viene visualizzata nell'elenco dei file recenti nell'ambiente Start.
Aggiungi il logo del programma alla miniatura generata Se selezionato, il logo del programma FreeCAD FreeCAD-logo.svg viene aggiunto alla miniatura. Questa opzione ha effetto solo se viene usato Salva la miniatura nel file del progetto al salvataggio del documento.
Massimo numero di file di backup da conservare quando si salva nuovamente il documento Se selezionato, i file di backup vengono conservati quando si salva il documento. È possibile specificare il numero di file di backup da conservare. Contengono la versione del documento salvata in precedenza. Il primo file di backup ha il suffisso del file .FCStd1, il secondo .FCStd2 e così via.
Consenti la duplicazione delleetichette degli oggetti nello stesso documento Se selezionato, gli oggetti possono avere la stessa etichetta o nome. Ad esempio, parti o caratteristiche diverse possono avere lo stesso nome nello stesso documento.
Nome autore Tutti i documenti che vengono creati ottengono il nome dell'autore specificato. Lasciare il campo dell'autore vuoto per un autore anonimo. Se viene selezionata l'opzione Imposta su salva, il campo Ultima modifica effettuata da: sarà impostato sull'autore specificato al momento del salvataggio del file. Questo campo può essere visualizzato utilizzando il menu File → Informazioni sul progetto.
Azienda Tutti i documenti creati ottengono il nome della società specificata
Licenza di default Selezione di una licenza predefinita per nuovi documenti. Per la licenza predefinita, URL della licenza viene automaticamente impostato di conseguenza. Selezionare 'Altro' per una licenza propria o speciale.
URL della licenza Specifica un URL che descrive la licenza selezionata in Licenza di default
Preference General Tab 02.png


Editore

Le impostazioni delle preferenze dell'editor influiscono sul comportamento dell'editor delle macro. Questo editor può essere aperto usando il menu Macro → Macros... → Modifica/Crea.
Nota: le impostazioni di colore e carattere influenzano anche la console Python. Questa console viene mostrata usando il menu Visualizza → Pannelli → Console Python.

In the Editor tab you can specify the following:

Name Description
Display Items Selection of the code type. The color and font settings will be applied to the selected type. The result can be seen in the Preview field.
Family Specification of the font family that should be used for the selected code type
Size Specification of the font size that should be used for the selected code type
Enable line numbers If checked, the code lines will be numbered
Tab size Specification of the tabulator raster (how many spaces). If it is for example set to '6', pressing Tab will jump to character 7 or 13 or 19 etc., depending the current cursor position. This setting is only used if Keep tabs is selected.
Indent size Specification of how many spaces will be inserted when pressing Tab. This setting is only used if Insert spaces is selected.
Keep tabs If selected, pressing Tab will insert a tabulator with the raster defined by Tab size
Insert spaces If selected, pressing Tab will insert the amount of spaces defined by Indent size
Preference General Tab 03.png


Finestra di output

In the Output tab you can specify the following:

Name Description
Record log messages If checked, also log messages will be recorded. They will be output in the Report view panel with the color set in Log messages. This panel is shown using the menu View → Panels → Report view.
Record warnings If checked, warnings will be recorded. They will be output in the Report view panel with the color set in Warnings.
Record error messages If checked, error messages will be recorded. They will be output in the Report view panel with the color set in Errors
Normal messages Specification of the font color for normal messages in the Report view panel.
Log messages Specification of the font color for log messages in the Report view panel.
Warnings Specification of the font color for warning messages in the Report view panel.
Errors Specification of the font color for error messages in the Report view panel.
Redirect internal Python output to report view If checked, internal Python output will be redirected from the Python console to the Report view panel. The Python console is shown using the menu View → Panels → Python console
Redirect internal Python errors to report view If checked, internal Python error messages will be redirected from the Python console to the Report view panel.
Preference General Tab 04.png


Macro

In the Macro tab you can specify the following:

Name Description
Run macros in local environment If checked, variables defined by macros are created as local variables, otherwise as global Python variable
Macro path Specification of a path to macro files
Recording GUI commands If checked, recorded macros will also contain user interface commands
Record as comment If checked, recorded macros will also contain user interface commands but as comments. This is useful if you don't want to execute visible actions when running the macro but to see what could be done visibly.
Show script commands in python console If checked, the commands executed by the macro scripts are shown in the Python console. This console is shown using the menu View → Panels → Python console.
Preference General Tab 05.png


Unità

In the Units tab you can specify the following:

Name Description
User system Selection of a unit system that should be used for all parts of FreeCAD
Number of decimals The number of decimals that should be shown for numbers and dimensions in FreeCAD
Minimum fractional inch Minimum fractional inch that should be displayed. This setting is only available if the unit system Building US (ft-in/sqft/cuft) is used.
Preference General Tab 06.png


Impostazioni di visualizzazione

Questa sezione delle preferenze ha 3 schede:

Vista 3D

Le impostazioni di Import-Export influenzano il modo in cui i file vengono importati ed esportati in e da FreeCAD. Si noti che la finestra di dialogo delle preferenze di importazione e esportazione offre le impostazioni del tipo di file per la maggior parte dei workbench ma non tutti gli ambienti di lavoro sono in grado di importare e esportare tutti i tipi di file.

In the 3D View tab you can specify the following:

Name Description
Show coordinate system in the corner If checked, the main coordinate system will always be shown at the lower right in opened files
Show counter of frames per second If checked, the time needed for the last operation and the resulting frame rate will always be shown at the lower left in opened files
Show navigation cube If checked, the navigation cube will always be shown at the selected Corner in opened files
Use OpenGL Vertex Buffer Object If checked, Vertex Buffer Objects (VBO) will be used. A VBO is an OpenGL feature that provides methods for uploading vertex data (position, normal vector, color, etc.) to the video device. VBOs offer substantial performance gains because the data resides in the video device memory rather than the system memory and so it can be rendered directly by the video device. For more background info see this webpage.
Enable animation If checked, rotations can be animated. If for example the 3D Navigation set CAD is used and the mouse is moved while the scroll wheel and the right mouse button is pressed, parts are rotated. If one keeps the mouse moving while releasing e.g. the right mouse button, the rotation will continue as animation. To end the animation left-click with the mouse.
3D Navigation Selection of a navigation settings set. To see what each set defines, select a set and press the button Mouse....
Orbit style Selection of the rotation orbit style. When viewing a part in the x-y plane an being in the rotation mode of the 3D navigation, the difference is: If Trackball is selected, moving the mouse horizontally will rotate the part around the y-axis, if Turntable is selected the part will be rotated around the z-axis.
Anti-Aliasing Selection if and what kind of multisample anti-aliasing is used
New Document Camera Orientation Selection of the camera orientation for new documents
Zoom at cursor If checked, zoom operations will be performed at the position of the mouse pointer. Otherwise zoom operations will be performed at the center of the current view. The Zoom step defines how much will be zoomed. A zoom step of '1' means a factor of 7.5 for every zoom step.
Invert zoom If checked, the direction of zoom operations will be inverted.
Disable touchscreen tilt gesture If checked, the tilting gesture will be disabled for pinch-zooming (two-finger zooming). This only affects the 3D Navigation set Gesture.
Drag at cursor If checked, rotations in 3D will use the current cursor position as center for the rotation. Otherwise always the center of the screen will be used.
Marker size Selection of the size of vertices (points) in the Sketcher workbench
Eye to eye distance for stereo modes Specification of the eye-to-eye distance used for stereo projections. The specified value is a factor that will be multiplied with the bounding box size of the 3D object that is currently displayed.
Enable backlight color If checked, backlight is enabled with the defined color
Intensity of backlight Specification of the intensity of the backlight. This setting is only enabled if Enable backlight color is checked.
Camera type Selection of the camera projection type.
If Perspective rendering is selected, objects will appear in a perspective projection.
If Orthographic rendering is selected, objects will be projected in orthographic projection.
Preference Display Tab 01.png


Colori

FreeCAD supporta molti formati di file. Per i seguenti formati di file offre l'applicazione di impostazioni speciali:

In the Colors tab you can specify the following:

Name Description
Enable preselection highlighting If checked, preselection is turned on and will be highlighted by the specified color. Preselection means that for example edges in parts will be highlighted while hovering with the mouse over them to indicate that they can be selected.
Enable selection highlighting If checked, selection highlighting is turned on and the specified color will be used for it
Pick radius Sets the area for picking elements in 3D view. Larger value makes it easier to pick things, but can make some small features impossible to select.
Simple color If selected, the background for parts will have the selected color
Color gradient If selected, the background for parts will have the selected color gradient
Middle color Is only enabled if Color gradient is selected. If checked, the color gradient will get the selected color as middle color.
Object being edited Selection of the background color for objects in the tree view that are currently edited
Active container Selection of the background color for active containers in the tree view. For example if there are several parts in the tree view and one part is toggled as active body, it will get the selected background color in the tree view.
Preference Display Tab 02.png


Colori della parte

Questa scheda viene mostrata solo se ci si trova nell'ambiente Part o PartDesign o se si è già stati prima in questi ambienti di lavoro.

In the Part colors tab you can specify the following:

Name Description
Default shape color Selection of the default color for new shapes. If the option Random shape color is set, a random color is used instead.
Default line color Selection of the default line color for new shapes
Default line width Specification of the default line thickness for new shapes
Default vertex color Selection of the default color for new vertices
Default vertex size Specification of the default size for new vertices
Bounding box color Selection of the color of bounding boxes in the 3D view
Default text color Selection of the default text color for document annotations. There is currently no dialog to add annotations to documents. Annotations can only be added using the Python console with this command:
obj=App.ActiveDocument.addObject("App::Annotation","Label")
This console is shown using the menu View → Panels → Python console.
Preference Display Tab 03.png


Mesh view

This tab is only shown if you are in the Mesh workbench or if you have been in this workbench before.

In the Mesh view tab you can specify the following:

Name Description
Default mesh color Selection of the default color for new meshes
Default line color Selection of the default line color for new meshes
Mesh transparency Specification of the default mesh transparency for new meshes
Line transparency Specification of the default line transparency for new meshes
Two-side rendering If checked, the bottom side of the surface will be rendered the same way than the top side. If not checked, it depends on the option Enable backlight color (see section 3D view). Either the backlight color will be used or black.
Show bounding-box for highlighted or selected meshes If checked, a yellow bounding box will be displayed for highlighted or selected meshes.
Define normal per vertex If checked, Phong shading is used, otherwise flat shading. Shading defines the appearance of surfaces.

With flat shading the surface normals are not defined per vertex that leads to a unreal appearance for curved surfaces while using Phong shading leads to a smoother appearance.

Crease angle The crease angle is a threshold angle between two faces. It can only be set if the option Define normal per vertex is used.
If face angle ≥ crease angle, facet shading is used
If face angle < crease angle, smooth shading is used

Mesh View Preferences.png

Impostazioni di importazione e esportazione

The Import-Export settings affect how files are imported and exported to and from FreeCAD. They are described in the page Import Export Preference.


Workbench preferences

Preferences for the more common workbenches are linked below. Some workbenches have no preferences. Other optional workbenches may not be listed.


A2plus Preferences

Il modulo Draft ha una propria finestra di dialogo per le preferenze

Draft Preferences

Drawing Preferences (none)

Fem Preferences

Image Preferences (none)

Inspection Preferences (none)

Mesh Design Preferences (none)

OpenSCAD Preferences

Part Preferences (none)

Part Design Preferences (none)

Path Preferences

Plot Preferences (none)

Points Preferences (none)

Raytracing Préférences

Reverse Engineering Preferences (none)

Robot Preferences (none)

Ship Preferences (none)

Sketcher Preferences

Spreadsheet Preferences (none)

Surface Preferences (none)

TechDraw Preferences

Test Framework Preferences (none)


Web Preferences (none)

Arrow-left.svg Struttura dei file di FreeCad Pagina precedente:
Pagina successiva: Personalizzare l'interfaccia Arrow-right.svg


Arrow-left.svg Impostare le preferenze Pagina precedente:
Pagina successiva: Editore delle proprietà Arrow-right.svg

Dato che l'interfaccia di FreeCAD è basata sul moderno toolkit Qt, essa dispone di una organizzazione ottimale. Si possono modificare, spostare, condividere tra i vari ambienti di lavoro widget, menu, barre e altri strumenti. Si possono creare e modificare le scorciatoie da tastiera. Si possono registrare e riprodurre le macro.

La finestra di personalizzazione è accessibile dal menu Strumenti → Std DlgCustomize.png Personalizza':

MenuPersonalizza.png

La scheda Personalizza

La scheda Comandi consente di esplorare tutti i comandi disponibili in FreeCAD, organizzati per categorie.

In Tastiera, è possibile vedere le scorciatoie da tastiera associate a ogni comando di FreeCAD, e volendo, si può modificare o assegnare un nuovo collegamento a qualsiasi comando. Quando si usa sovente uno specifico ambiente di lavoro, questo permette di velocizzare il suo utilizzo tramite la tastiera.

La scheda Barre degli strumenti consente di modificare le barre degli strumenti esistenti, o di creare nuove barre degli strumenti personalizzate.

La scheda Macro consente di gestire le Macro salvate in precedenza.

Le schede successive permettono di impostare le azioni di Spaceball (se installato)

Vedere anche il tutorial per creare la Barra personalizzata degli strumenti macro

Dalla versione 0.16 è disponibile un nuovo strumento che permette di gestire gli ambienti di lavoro.

CustomizeWorkbenches.png

Esempio

Come esempio del flusso di lavoro, supponiamo di voler avere la funzione "Misura Lineare" mostrata anche in una barra degli strumenti personalizzata nell'ambiente Draft.

  • dal menu principale di FreeCAD scegliere Strumenti → Personalizza
  • selezionare la tabella "Barre degli strumenti"
  • sul lato sinistro scegliere "Part" nel menu a discesa
  • sul lato sinistro della finestra scorrere in basso fino alla voce "Misura Lineare" e selezionarla
  • sul lato destro scegliere "Draft" nel menu a discesa
  • cliccare su Nuova... per creare una nuova barra degli strumenti e definire il suo nome
  • ora selezionare la barra degli strumenti di destinazione nella finestra in basso a destra (è necessario solo se si dispone di più di una barra degli strumenti)
  • cliccando sulla "Freccia destra" di colore blu (l'icona in alto nella fila centrale) si aggiunge la voce selezionata alla barra degli strumenti selezionata

Osservazioni:

  • quando si seleziona "Global" nel menu a tendina sulla parte di destra si crea una barra degli strumenti che sarà visibile in tutti gli ambienti

Per aggiungere ad una barra degli strumenti una macro installata è necessario

  • selezionare "Macro" nel menu a discesa sul lato sinistro
  • aver assegnato il testo del menu, l'icona (Pixmap) e così via utilizzando il menu Strumenti → Personalizza → Macro


Arrow-left.svg Impostare le preferenze Pagina precedente:
Pagina successiva: Editore delle proprietà Arrow-right.svg


Una Proprietà è una parte di informazione sotto forma di numero o di stringa di testo che viene allegata a un documento FreeCAD oppure a un oggetto in un documento. Le proprietà possono essere visualizzate e, se consentito, modificate con l'editor delle proprietà.

In FreeCAD le proprietà svolgono un ruolo molto importante in quanto esso è concepito per lavorare con oggetti parametrici, ovvero oggetti definiti solo dalle loro proprietà.

In FreeCAD gli oggetti script personalizzati possono avere proprietà dei seguenti tipi:

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
Arrow-left.svg Personalizzare l'interfaccia Pagina precedente:
Pagina successiva: Ambienti di lavoro Arrow-right.svg


Arrow-left.svg Editor delle proprietà Pagina precedente:
Pagina successiva: Ambiente Arch Workbench Arch.svg Arrow-right.svg

FreeCAD, come molte altre applicazioni di grafica moderne quali Revit o Catia, è strutturato in Ambienti di lavoro definiti Workbench.

Ogni ambiente offre gli strumenti necessari, opportunamente riuniti, per svolgere un compito specifico.

Si pensi, come esempio, ad un laboratorio di mobili dove c'è un banco di lavoro per chi lavora il legno, un altro per chi lavora i pezzi di metallo, e forse un terzo per chi assembla tutti i componenti.

In FreeCAD, viene applicato lo stesso concetto. Gli strumenti sono raggruppati per ambienti in base alle funzioni correlate.

Quando si passa da un ambiente di lavoro ad un altro, cambiano anche gli strumenti disponibili visualizzati sull'interfaccia. Le barre degli strumenti, le barre dei comandi e eventualmente altre parti dell'interfaccia si adattano al nuovo ambiente, ma il contenuto della scena visualizzata non cambia. Si può, ad esempio, iniziare a disegnare forme 2D utilizzando l'ambiente Draft e poi continuare a lavorare su di esse con l'ambiente Parte.

Notare che a volte un Ambiente viene indicato come un Modulo. Gli Ambienti e i Moduli sono però entità diverse. Un modulo è una estensione di FreeCAD, mentre un ambiente di lavoro è una speciale configurazione dell'interfaccia grafica che raggruppa alcune barre degli strumenti e dei menu specifici. Di solito, ogni modulo contiene anche il proprio ambiente di lavoro, e viceversa, ogni ambiente dipende da un modulo, per questo motivo succede di fare un uso incrociato del nome.

Ambienti incorporati

Attualmente in tutte le installazioni di FreeCAD sono disponibili i seguenti ambienti:

  • Workbench Arch.svg Arch per lavorare con gli elementi architettonici
  • Workbench Complete.svg Complete contiene tutti i comandi e le funzioni di tutti i moduli e ambienti di lavoro che soddisfano determinati criteri di qualità. Deprecato in v0.17
  • Workbench Draft.svg Draft Contiene gli strumenti 2D e quelli per realizzare le operazioni di base di tipo CAD 2D e 3D
  • Workbench Drawing.svg Disegno (Drawing) era usato per le proiezioni del modello 3D su un foglio 2D ma ora è deprecato, è ancora necessario leggere i vecchi file di FreeCAD che contengono un disegno creato originariamente con questo ambiente. Vedere TechDraw, che è una sostituzione più avanzata.
  • Workbench FEM.svg FEM per Analisi agli elementi finiti (FEA)
  • Workbench Image.svg Image per lavorare con immagini bitmap (matrice)
  • Workbench Inspection.svg Inspection fornisce gli strumenti specifici per esaminare le forme. È ancora in sviluppo.
  • Workbench Mesh.svg Mesh per lavorare con grigliature a maglie triangolari
  • Workbench OpenSCAD.svg OpenSCAD per interagire con OpenSCAD e riparare lo storico del modello CSG
  • Workbench Part.svg Parte (Part) per lavorare con oggetti CAD di tipo Parte 3D
  • Workbench PartDesign.svg Part Design per costruire oggetti di tipo Parte utilizzando degli schizzi come base
  • Workbench Path.svg Percorso per produrre istruzioni G-Code. È ancora in fase iniziale di sviluppo.
  • Workbench Plot.svg Grafico (Plot) per editare e salvare i grafici sviluppati da altri moduli e strumenti (in fase di sviluppo)
  • Workbench Points.svg Punti per lavorare con nuvole di punti.
  • Workbench Raytracing.svg Raytracing per operazioni di rendering con ray-tracing (fotorealismo)
  • Workbench Reverse Engineering.svg Ingegneria inversa (Reverse Engineering) fornisce gli strumenti specifici per convertire forme/solidi/maglie in funzioni parametriche compatibili con FreeCAD. È ancora in sviluppo.
  • Workbench Robot.svg Robot per studiare i movimenti del robot
  • Workbench Ship.svg Ship per operare su entità navali costruite su geometrie di base.
  • Workbench Sketcher.svg Sketcher per lavorare con degli schizzi vincolati geometricamente
  • Workbench Spreadsheet.svg Foglio di calcolo (Spreadsheet) per creare un foglio di calcolo e manipolare i dati
  • Workbench Start.svg Start Center consente di passare rapidamente in uno degli ambienti di lavoro più comuni.
  • Workbench Surface.svg Surface workbench Fornisce strumenti per creare e modificare superfici. È simile al builder Part Shape Face from edges.
  • Workbench TechDraw.svg TechDraw è il successore di Disegno, è più avanzato e ricco di funzionalità
  • Workbench Test.svg Test per la messa a punto (debug) di FreeCAD.
  • Workbench Web.svg Web offre una finestra del browser nella vista 3D di FreeCAD.

Ambienti aggiuntivi

Gli ambienti di lavoro per FreeCAD sono facilmente programmabili in Python, quindi ci sono molte persone che stanno sviluppando degli ambienti aggiuntivi al di fuori dell'area principale di sviluppo di FreeCAD.

La pagina Ambienti complementari elenca tutti quelli che sono noti a questa comunità. La maggior parte è facilmente installabile da FreeCAD, usando Addon manager, che si trova nel menu Strumenti → AddonManager.svg Addon manager.

Sono in fase di sviluppo ulteriori nuovi ambienti, mantenetevi aggiornati.

Arrow-left.svg Editor delle proprietà Pagina precedente:
Pagina successiva: Ambiente Arch Workbench Arch.svg Arrow-right.svg


Arrow-left.svg InspectionWorkbench.svg Ambiente Inspection Pagina precedente:
Pagina successiva: Ambiente OpenSCAD OpenSCADWorkbench.svg Arrow-right.svg

Workbench Mesh.svg

Introduzione

L'ambiente Mesh gestisce i reticoli triangolari degli oggetti mesh.

Gli oggetti mesh sono un tipo speciale di oggetti 3D, composti da facce triangolari (le maglie della griglia) connesse lungo i loro bordi e nei loro vertici. Oggetti tessellati.

Molte applicazioni 3D utilizzano i mesh come tipo principale di oggetti 3D, ad esempio: Sketchup, Blender, Maya e 3D Studio Max. Dato che i mesh sono oggetti molto semplici, contenenti solo vertici (punti), bordi e facce (triangoli), sono molto facili da creare, modificare, suddividere, allungare, e altrettanto facili da trasferire da un'applicazione all'altra senza alcuna perdita di informazioni. Inoltre, dal momento che contengono dati molto semplici, le applicazioni 3D ne possono gestire grandi quantità senza alcun problema. Per queste ragioni, gli oggetti mesh sono spesso il tipo di oggetto 3D utilizzato dalle applicazioni che si occupano di cinema, animazione e creazione di immagini.

Tuttavia, nel campo delle mesh ingegneristiche presentano una grande limitazione: sono fatti solo di superfici e non hanno informazioni di massa, quindi non si comportano come solidi. Ciò significa che tutte le operazioni basate su solidi, come addizione o sottrazione, sono difficili da eseguire sulle mesh. L'ambiente Mesh è utile per importare dati 3D in formato mesh, per analizzarli, rilevare errori e infine convertirli in un solido, per poterli usare con l'ambiente Part.

Mesh example.jpg

Strumenti

Il modulo Mesh ha una interfaccia molto semplice, tutte le sue funzioni sono raggruppate nelle voci del menu Mesh/it.

Strumenti generali

Analizza

Analizza la curvatura, le facce, e verifica se un oggetto mesh può essere convertito senza inconvenienti in un solido

Solido regolare

Mesh Regular Solid.png Regular solid...: crea primitive mesh, come cubi, cilindri, coni o sfere.

Operazioni booleane

  • Unione: esegue una unione (fusione) di mesh.
  • Intersezione: esegue una intersezione (parte comune) di mesh.
  • Differenza: esegue una differenza (taglio) di mesh.

Cutting

Altro

Preferenze

Altri strumenti mesh sono disponibili nell'ambiente OpenSCAD.


FreeCAD può gestire gli oggetti grigliati in molti altri modi tramite gli script Mesh.

Link

Arrow-left.svg InspectionWorkbench.svg Ambiente Inspection Pagina precedente:
Pagina successiva: Ambiente OpenSCAD OpenSCADWorkbench.svg Arrow-right.svg


Arrow-left.svg OpenSCADWorkbench.svg Ambiente OpenSCAD Pagina precedente:
Pagina successiva: Ambiente PartDesign Workbench PartDesign.svg Arrow-right.svg

Workbench Part.svg

Introduzione

Le funzionalità CAD di FreeCAD sono basate sul kernel Open Cascade Technology (OCCT), un sistema CAD di livello professionale che offre funzionalità avanzate per la creazione e manipolazione della geometria 3D. L'ambiente Part è uno strato che si trova sopra le librerie OCCT, che fornisce all'utente l'accesso alle primitive e alle funzioni geometriche OCCT. Essenzialmente tutte le funzioni di disegno 2D e 3D in FreeCAD, negli ambienti Draft, Sketcher, PartDesign, ecc. si basano su queste funzioni esposte dall'ambiente Parte. Pertanto, Part può essere considerato il componente principale delle funzioni di disegno di FreeCAD.

Gli oggetti creati con Part sono relativamente semplici; sono pensati per essere utilizzati con le operazioni booleane (unioni e tagli) al fine di costruire forme più complesse. Questo paradigma di modellazione è noto come flusso di lavoro geometria solida costruttiva (CSG) ed era la metodologia tradizionale utilizzata nei primi sistemi CAD. D'altra parte, l'ambiente PartDesign fornisce un flusso di lavoro più moderno per la costruzione di forme: utilizza schizzi parametrici definiti, che vengono estrusi per formare un corpo solido di base, che viene poi modificato da trasformazioni parametriche (editazione delle funzioni), fino a quando non si ottiene l'oggetto finale.

Gli oggetti Parte sono più complessi degli oggetti mesh creati con l'ambiente Mesh, e consentono operazioni più avanzate come le operazioni booleane coerenti, la cronologia delle modifiche e il comportamento parametrico.

Part example.jpg

Part Workbench relationships.svg

Part Workbench è lo strato base che espone le funzioni di disegno OCCT a tutti i workbench di FreeCAD


Gli strumenti

Gli strumenti del modulo Parte sono tutti situati nel menu Parte che viene visualizzato quando si carica questo modulo.

Primitive

Questi sono strumenti per creare oggetti primitivi.

  • Part Box.png Prisma: disegna parallelepipedi specificandone le dimensioni
  • Part Cylinder.png Cilindro: disegna solidi cilindrici.
  • Part Sphere.png Sfera: disegna sfere.
  • Part Cone.png Cono: disegna solidi conici.
  • Part Torus.png Toro: disegna anelli.
  • Part CreatePrimitives.png Crea Primitive: strumento per creare varie primitive geometriche parametriche
  • Part Shapebuilder.png Generatore di forma: strumento per creare delle forme complesse da primitive geometriche parametriche

Modificare gli oggetti

Questi sono gli strumenti per modificare gli oggetti esistenti. Essi permettono di scegliere l'oggetto da modificare.

  • Part Extrude.png Estrudi: Estrude le facce planari di un oggetto
  • Part Revolve.png Rivoluziona: Crea un oggetto tramite la rotazione di un altro oggetto attorno ad un asse
  • Part Mirror.png Specchia: Riflette l'oggetto selezionato rispetto ad un asse stabilito
  • Part Fillet.png Raccorda: Raccorda (arrotonda) i bordi di un oggetto
  • Part Chamfer.png Smussa: Smussa i bordi di un oggetto
  • Part RuledSurface.png Superficie rigata: Crea una superficie tra due linee
  • Part Loft.png Loft: Crea una estrusione tra due sagome diverse
  • Part Sweep.png Sweep: Estrude un profilo seguendo un percorso determinato
  • Part CompOffsetTools.png Strumenti offset:
    • Part Offset.png Offset 3D: Crea una forma parallela ad una data distanza dall'originale.
    • Part Offset2D.png Offset 2D: Crea un contorno parallelo ad una certa distanza dall'originale, ingrandisce o contrae una faccia piana. (v0.17)
  • Part Thickness.png Spessore: Scava un solido, lasciando aperte le facce selezionate.
  • Part ProjectionOnSurface.png Proiezione su superficie: Proietta un logo, un testo o qualsiasi faccia, polilinea, bordo su una superficie. Con la parte di proiezione è possibile creare un solido o una polilinea. (v0.19)
  • Part CompSplittingTools.png Dividi: Strumenti di suddivisione (v0.17)
    • Part BooleanFragments.png Frammenti booleani: Restituisce tutte le parti che possono essere ottenute con operazioni booleane tra oggetti (v0.17)
    • Part SliceApart.svg Affetta in parti: strumento per dividere le forme per intersezione con altre forme
    • Part Slice.png Affetta in composto: Divide un oggetto nelle parti ottenute intersecando l'oggetto con un altro oggetto (v0.17)
    • Part XOR.png Booleana XOR: Rimuove lo spazio condiviso dagli oggetti (versione simmetrica di Taglia) (Or esclusivo) (v0.17)
  • Part Defeaturing.svg Elimina funzioni: (v0.18)
  • Part Section.png Seziona: Crea una sezione intersecando un oggetto con un altro oggetto
  • Part SectionCross.png Sezioni...: Crea una sezione intersecando un oggetto con uno o più piani di sezione

Altri strumenti

  • Part ImportCAD.png Importa CAD: Questo strumento consente di aggiungere un file *.IGES, *.STEP, *.BREP al documento corrente.
  • Part ExportCAD.png Esporta CAD: Questo strumento consente di esportare un oggetto parte in un file *.IGES, *.STEP, *.BREP.
  • Part ShapeFromMesh.png Crea forma da mesh: Crea un oggetto forma da un oggetto mesh.
  • Converti in solido: Converte un oggetto forma di un oggetto solido.
  • Inverti le forme: Capovolge le normali di tutte le facce dell'oggetto selezionato.
  • Crea una copia semplice: Crea una semplice copia dell'oggetto selezionato.
  • Part RefineShape.png Affina una forma: Pulisce le facce, eliminando le linee inutili.
  • Part CheckGeometry.png Controlla la geometria: Controlla se la geometria degli oggetti selezionati contiene degli errori.
  • Misura: Permette di eseguire misure lineari e angolari tra i punti, i bordi o le facce.
  • Part Attachment.svg Attachment: Attachment è un'utilità per collegare un oggetto a un altro.

Preferenze

OCCT Concetti base

Nella terminologia OpenCascade, si distingue tra primitive geometriche e forme (topologiche). Una primitiva geometrica può essere un punto, una linea, un cerchio, un piano, ecc o essere anche di tipo più complesso come una curva B-Spline o una superficie. Una forma può essere un vertice, un bordo, un profilo, una faccia, un solido o un insieme di più forme. Le primitive geometriche non sono fatte per essere visualizzate direttamente sulla scena 3D, ma piuttosto per essere utilizzate come geometrie per la costruzione di forme. Ad esempio, un bordo può essere costruito usando una linea o una porzione di un cerchio.

Potremmo dire, per riassumere, che le primitive geometriche sono blocchi di costruzione "informi", e le forme sono la reale geometria spaziale costruita su questi blocchi.

Per ottenere un elenco completo di tutti le primitive e shapesfare riferimento alla documentazione OCC cercare Geom_Geometry e TopoDS_Shape. Nella documentazione sono anche contenute ulteriori informazioni sulle differenze tra gli oggetti geometrici e le forme. La documentazione OCC non è disponibile online (è necessario scaricare un archivio) e si rivolge principalmente ai programmatori e non agli utenti finali. Si spera che le informazioni fornite in seguito siano sufficienti per iniziare.

I tipi di oggetti geometrici possono essere suddivisi in due gruppi principali: le curve e le superfici. Sulle curve (linea, cerchio, ...), è possibile creare direttamente un bordo, mentre sulle superfici (piano, cilindro, ...) è possibile costruire una faccia. Ad esempio, la linea primitiva geometrica è illimitata, ossia è definita da un vettore di base e da un vettore di direzione, mentre la sua forma (e rappresentazione) deve essere qualcosa di limitato da un punto iniziale e da un punto finale. E un cubo - solido - può essere creato da sei piani limitati.

Da un bordo o una faccia (forme) si può sempre risalire alla sua primitiva geometrica.

Utilizzando le forme, è possibile costruire parti molto complesse, oppure viceversa, si possono estrarre tutte le sotto-forme che compongono una forma complessa.

Script

Vedere anche: Script di Part

La struttura principale dei dati utilizzati nel modulo Parte di OpenCascade è il tipo di dati BRep . Quasi tutti i contenuti e i tipi di oggetti del modulo Parte sono ora disponibili per gli script Python. Questo include le primitive geometriche, come Linee e Cerchi (o Archi), e tutta la gamma di TopoShapes, come Vertici, Bordi, Contorni, Facce, Solidi e Compositi. Per ognuno di questi oggetti, esistono diversi metodi di creazione, e per alcuni di loro, soprattutto le TopoShapes, sono inoltre disponibili operazioni booleane avanzate come unione, differenza e intersezione. Per maggiori informazioni, esplorare il contenuto del modulo Parte, come descritto nella pagina Script.

Esempi

Per creare un elemento linea, passare alla console Python e digitare:

import Part,PartGui 
doc=App.newDocument()  
l=Part.LineSegment()
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()

Descrizione passo per passo della procedura del precedente esempio Python:

import Part,PartGui
doc=App.newDocument()

carica il modulo Parte e crea un nuovo documento

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

La funzione Line descrive in realtà un segmento di linea, quindi serve il punto iniziale e quello finale.

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

Questo comando aggiunge un oggetto di tipo Parte al documento e assegna la forma di rappresentazione del segmento di linea alla proprietà 'forma' (Shape) dell'oggetto aggiunto. È importante comprendere che abbiamo usato una primitiva geometrica (la Part.LineSegment) per creare una TopoShape su di essa (il metodo toShape()). Al documento possono essere aggiunte solo delle forme . In FreeCAD, le primitive geometriche vengono utilizzate come "strutture di base" per le forme.

doc.recompute()

Aggiorna il documento. Questo prepara anche la rappresentazione visiva del nuovo oggetto Parte.

Notare che una Line Segment può essere creata specificando il suo punto iniziale e il suo punto finale direttamente nel costruttore, per es. Part.Line Segment(point1, point2) oppure possiamo creare una linea predefinita e impostarne le proprietà in seguito, come in questo caso.

In modo analogo è possibile creare un cerchio:

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

Si noti ancora una volta che il cerchio (geometria primitiva) viene usato per costruire una forma su di esso. Ovviamente, in seguito, si può ancora accedere alla geometria di costruzione con:

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

Qui si acquisisce la forma dell'oggetto f, poi si acquisisce la lista dei bordi, (in questo caso il bordo è uno solo perché si crea l'intera forma con un unico cerchio, quindi si definisce solo il primo elemento della lista Edges) e infine, si recupera la curva. Ogni bordo ha una curva, che è la geometria primitiva sulla quale è basato.

Per maggiori informazioni consultare la pagina Script di dati topologici

Tutorial

Arrow-left.svg OpenSCADWorkbench.svg Ambiente OpenSCAD Pagina precedente:
Pagina successiva: Ambiente PartDesign Workbench PartDesign.svg Arrow-right.svg


Arrow-left.svg Workbench Draft.svg Ambiente Draft Pagina precedente:
Pagina successiva: Ambiente FEM Workbench FEM.svg Arrow-right.svg

Workbench Drawing.svg

Introduzione

Lo sviluppo del modulo Drawing è stato interrotto in FreeCAD 0.16 con il proposito di sostituirlo con il nuovo modulo TechDraw che sarà introdotto nella versione 0.17. Nella versione 0.17 sono forniti entrambi i moduli, ma il modulo Drawing potrebbe essere rimosso nelle versioni future.


L'ambiente Disegno (Drawing) consente di trasferire su carta il lavoro realizzato in 3D.

Permette di produrre delle viste (proiezioni sul piano) del modello, di posizionarle in una finestra 2D e di inserire la finestra in una tavola, ad esempio, in un foglio con il bordo, il titolo e il logo e, infine, di stampare la tavola.

Drawing extraction.png

Strumenti

Questi strumenti permettono di creare, configurare e esportare le proiezioni dei solidi come disegni 2D.


  • Drawing New.png Apri SVG: apre un foglio di disegno preventivamente salvato in un file SVG.
  • Drawing Landscape A3.png Nuovo Disegno A3: crea un nuovo disegno su un foglio di default A3 orizzontale di FreeCAD.
  • Drawing Annotation.png Annotazione: aggiunge una annotazione al foglio di disegno corrente.
  • Drawing Clip.png Clip: aggiunge un gruppo di clip al foglio di disegno corrente.
  • Drawing Symbol.png Simbolo: aggiunge il contenuto di un file in formato SVG come un simbolo nel foglio di disegno corrente
  • Drawing DraftView.png Vista Draft: Inserisce una speciale vista Draft dell'oggetto selezionato nel foglio del disegno corrente

Flusso di lavoro

Il documento contiene un oggetto di forma 3D (Schenkel) da si vuole produrre un disegno. Pertanto viene creata una "Pagina". Una pagina è istanziata da un modello, ad esempio il modello "A3_Landscape". Il modello è un documento SVG che può contenere una cornice di pagina, un logo e altri elementi.

Nella pagina si possono inserire una o più viste. Ogni vista ha una posizione nella pagina, un fattore di scala (proprietà di scala) e delle proprietà aggiuntive. Ogni volta che la pagina, la vista o l'oggetto a cui si fa riferimento subiscono delle modifiche, la pagina viene rigenerata e viene anche aggiornata la sua visualizzazione.

Script

Per ora le funzioni offerte dall'interfaccia grafica (GUI) sono molto limitate, quindi gli script API sono più interessanti.

Vedere la pagina Esempi dell'API di Drawing per una descrizione delle funzioni utilizzate per creare pagine e viste di disegno.

Lo script Macro_CartoucheFC permette di compilare agevolmente la tabella del modello di tavola FreeCAD A3_Landscape.

Modelli di squadrature

FreeCAD viene fornito con una serie di modelli di pagina predefiniti, ma si possono trovare altri modelli in Modelli di squadrature.

Estendere il modulo Drawing

Alcune ulteriori note sulla programmazione del Modulo Disegno sono contenute nella pagina Drawing Documentation (en) Drawing Documentation (it). Dette note aiutano a capire rapidamente come lavora questo modulo e permettono ai programmatori di avviare rapidamente la programmazione per esso.

Tutorial

Link esterni

Arrow-left.svg Workbench Draft.svg Ambiente Draft Pagina precedente:
Pagina successiva: Ambiente FEM Workbench FEM.svg Arrow-right.svg


Arrow-left.svg PointsWorkbench.svg Ambiente Points Pagina precedente:
Pagina successiva: Ambiente Reverse Engineering ReverseEngineeringWorkbench.svg Arrow-right.svg

Workbench Raytracing.svg

Introduzione

Il modulo Raytracing viene utilizzato per generare immagini fotorealistiche dei modelli elaborandole con un renderer esterno.

Il modulo Raytracing lavora con dei modelli, che sono file di progetto che definiscono una scena per il modello 3D. È possibile posizionare luci e geometrie come i piani terra e contiene anche i segnaposto per la posizione della telecamera e per le informazioni sul materiale degli oggetti nella scena. Il progetto può quindi essere esportato in un file pronto per il rendering o essere eseguito direttamente in FreeCAD.

Attualmente sono supportati due renderizzatori: povray e luxrender. Per poter eseguire il rendering direttamente da FreeCAD, sul sistema deve essere installato almeno uno di questi renderer, e deve essere configurato il suo percorso nelle preferenze di FreeCAD per Raytracing. Senza alcun renderer installato, si può comunque esportare un file della scena e utilizzarlo successivamente in uno di questi renderer, o su una macchina diversa.

Attualmente vi è un nuovo Ambiente Renderer in fase di sviluppo per supportare diversi back-end, come Lux Renderer e YafaRay. Le informazioni per l'utilizzo della versione di sviluppo possono essere visionate nel progetto Render. Per lo stato di sviluppo del modulo Render, vedere il Progetto Raytracing.

Raytracing example.jpg

Flusso di lavoro tipico

  1. Creare o aprire un progetto di FreeCAD, aggiungere alcuni oggetti basati sul modulo Part (i mesh non sono ancora supportati)
  2. Creare un progetto Raytracing (luxrender o povray)
  3. Selezionare gli oggetti che si desidera aggiungere al progetto raytracing e aggiungerli con lo strumento "Inserisci Parte"
  4. Esportare o elaborare direttamente


Raytracing Workbench workflow.svg


Workflow of the Raytracing Workbench; the workbench prepares a project file from a given template, and then calls an external program to produce the actual rendering of the scene. The external renderer can be used independently of FreeCAD.


Strumenti

Strumenti di progetto

Questi sono gli strumenti principali per esportare il proprio lavoro 3D su renderer esterni.

  • Raytracing New.png Nuovo progetto PovRay: inserisce un nuovo progetto PovRay nel documento.
  • Raytracing Lux.png Nuovo progetto LuxRender: inserisce un nuovo progetto LuxRender nel documento.
  • Raytracing InsertPart.png Inserisci parte: inserisce una vista di una parte in un progetto di raytracing.
  • Raytracing ResetCamera.png Reset camera: abbina la posizione della telecamera di un progetto di raytracing alla vista corrente.
  • Raytracing ExportProject.png Esporta progetto...: esporta un progetto di raytracing in un file di scena per il rendering in un renderer esterno.
  • Raytracing Render.png Render: esegue il rendering di un progetto raytracing con un renderer esterno.

Utilità

Questi sono degli strumenti di supporto per eseguire manualmente azioni specifiche.

Preferenze

  • Std DlgParameter.png Preferenze: preferenze disponibili per gli strumenti Raytracing.

Tutorials

Creare manualmente un file povray

Gli strumenti di utilità descritti prima consentono di esportare la corrente vista 3D e tutto il suo contenuto in un file Povray. In primo luogo, è necessario caricare un documento o crearne uno e poi orientare la vista 3D come si desidera. Dopo, scegliere Esporta la vista ... nel menu di Raytracing.

FreeCAD Raytracing.jpg

Nella finestra di dialogo Esporta pagina, selezionare la destinazione per salvare il file *.pov. Successivamente aprire il file in Povray e generare la renderizzazione:

Povray.jpg

Come è noto, le applicazioni di renderizzazione possono produrre immagini di grandi dimensioni e ottima qualità:

Scharniergreifer render.jpg

Script

Vedere Esempio di API Raytracing per informazioni sulla scrittura di scene a livello di codice.

Link

POVRay

Luxrender

Render per future implementazioni

Esportare in Kerkythea

Sebbene l'esportazione diretta nel formato XML di Kerkythea non sia ancora supportata, è possibile esportare gli oggetti come file Mesh (.obj) e poi importarli in Kerkythea.

  • se si utilizza Kerkythea per Linux, ricordarsi di installare il pacchetto WINE (necessario per far funzionare Kerkythea in Linux)
  • è possibile convertire i modelli in mesh con l'aiuto dell'ambiente Mesh e poi esportare questi mesh, come file .obj
  • If your mesh-export resulted in errors (flip of normals, holes ...) you may try your luck with netfabb studio basic
Free for personal use, available for Windows, Linux and Mac OSX.
It has standard repair tools which will repair you model in most cases.
  • another good program for mesh analysing/repairing is Meshlab
Open Source, available for Windows, Linux and Mac OSX.
It has standard repair tools which will repair you model in most cases (fill holes, re-orient normals, etc.)
  • è possibile utilizzare "make compound" e poi "make single copy" oppure è possibile fondere i solidi in un gruppo prima di convertirli in mesh
  • ricordatevi di impostare in Kerkythea un fattore di importazione di 0.001 per obj-modeler, in quanto Kerkythea si aspetta che il file obj sia in m (ma l'unità standard in FreeCAD è il mm)
Within WIndows 7 64-bit Kerkythea does not seem to be able to save these settings.
So remember to do that each time you start Kerkythea
  • se si importano più oggetti in Kerkythea è possibile utilizzare la funzione "File> Unisci" di Kerkythea
Arrow-left.svg PointsWorkbench.svg Ambiente Points Pagina precedente:
Pagina successiva: Ambiente Reverse Engineering ReverseEngineeringWorkbench.svg Arrow-right.svg


Arrow-left.svg Workbench FEM.svg Ambiente FEM Pagina precedente:
Pagina successiva: Ambiente Inspection InspectionWorkbench.svg Arrow-right.svg

Workbench Image.svg

Introduzione

Il modulo Immagine gestisce diversi tipi di immagini bitmap, e permette di aprirle in FreeCAD.

Attualmente, il modulo consente di aprire file di formato BMP, JPG, PNG, e XPM.

Strumenti

  • Image-import.svg Apri: apre un'immagine in una nuova finestra.
  • Image-import-to-plane.svg Importa immagine: importa un'immagine su un piano nella vista 3D.
  • Image-scale.svg Scala: ridimensiona un'immagine importata su un piano.

Funzioni

  • Come avviene con uno Schizzo, un'immagine importata può essere collegata a uno dei piani principali XY, XZ o YZ e viene fornito un offset positivo o negativo.
  • L'immagine viene importata con una relazione di 1 pixel in 1 millimetro.
  • La raccomandazione è di importare un'immagine con una risoluzione ragionevole.

Flusso di lavoro

Un uso importante di questo ambiente è il tracciamento sull'immagine, con gli strumenti di Draft o Sketcher, per generare un corpo solido basato sui contorni dell'immagine.

Tracciare su un'immagine funziona meglio se l'immagine ha un piccolo offset negativo, ad esempio di -0,1 mm, dal piano di lavoro. Ciò significa che l'immagine è leggermente dietro al piano in cui si disegna la geometria 2D, in modo da non disegnare sull'immagine stessa.

L'offset dell'immagine può essere impostato durante l'importazione o modificato successivamente attraverso le sue proprietà.

Arrow-left.svg Workbench FEM.svg Ambiente FEM Pagina precedente:
Pagina successiva: Ambiente Inspection InspectionWorkbench.svg Arrow-right.svg



Arrow-left.svg Workbench Arch.svg Arch Pagina precedente:
Pagina successiva: Drawing Workbench Drawing.svg Arrow-right.svg

Workbench Draft.svg

Introduzione

L'ambiente Draft consente di disegnare semplici oggetti 2D e offre diversi strumenti per modificarli in seguito. Fornisce inoltre strumenti per definire un piano di lavoro, una griglia e un sistema di snap per controllare con precisione la posizione della geometria.

Gli oggetti 2D creati possono essere utilizzati per per il disegno in modo simile a Inkscape o Autocad. Queste forme 2D possono anche essere utilizzate come componenti di base di oggetti 3D creati con altri ambienti di lavoro, ad esempio con Part e Arch. È anche possibile gli oggetti Draft in Schizzi, il che significa che le forme possono essere utilizzate anche con PartDesign per creare dei corpi solidi.

FreeCAD è principalmente un'applicazione di modellazione 3D, quindi i suoi strumenti 2D non sono così avanzati come in altri programmi di disegno. Se l'obiettivo principale è la produzione di disegni 2D complessi e di file DXF, e non si ha bisogno di modelli 3D, si può prendere in considerazione un programma software dedicato al disegno tecnico come LibreCAD, QCad, TurboCad e altri.

Draft Workbench Example.png

Strumenti per disegnare oggetti

Questi sono gli strumenti per creare gli oggetti

  • Draft Line.svg Linea: disegna un segmento delimitato da due punti.
  • Draft Wire.svg DWire: disegna una spezzata o polilinea specificando tutti i punti intermedi.
  • Draft Circle.svg Cerchio: disegna una circonferenza prendendo in input il centro e il raggio.
  • Draft Arc.svg Arco: disegna un arco di circonferenza a partire dal centro e specificando il raggio, l'angolo iniziale e l'angolo finale.
  • Draft Arc 3Points.svg Arco da 3 punti: disegna un segmento di arco circolare da tre punti che si trovano nella circonferenza. Disponibile dalla versione 0.19
  • Draft Ellipse.svg Ellisse: disegna una ellisse.
  • Draft Polygon.svg Poligono: disegna un poligono regolare da centro, raggio e numero di lati.
  • Draft Rectangle.svg Rettangolo: disegna un rettangolo specificando gli angoli opposti.
  • Draft Text.svg Testo: disegna delle annotazioni multilinea.
  • Draft Dimension.svg Quota: aggiunge la quotatura.
  • Draft BSpline.svg B-Spline: interpola una traiettoria curvilinea passante per i punti specificati.
  • Draft Point.svg Punto: inserisce un oggetto punto.
  • Draft ShapeString.svg Forma da testo: ShapeString inserisce una forma composta da una stringa di testo.
  • Draft Facebinder.svg Lega facce: Facebinder crea un nuovo oggetto costituito dalle facce selezionate in una forma.
  • Draft BezCurve.svg Curva di Bezier: disegna curve di Bezier su una serie di punti
  • Draft CubicBezCurve.svg Curva di Bézier cubica: disegna una curva di Bézier di terzo grado trascinando due punti. Disponibile dalla versione 0.19
  • Draft Label.svg Etichetta: posiziona un'etichetta con una freccia che punta a un elemento selezionato Disponibile dalla versione 0.17

Strumenti per modificare gli oggetti

Si tratta degli strumenti per la modifica di oggetti esistenti. Lavorano su oggetti selezionati precedentemente, quando nessun oggetto è selezionato, si viene invitati a scegliere uno.

Molti strumenti operativi (spostamento, rotazione, array, ecc.) Funzionano anche su oggetti solidi di (Part, PartDesign, Arch, ecc.).

Strumenti di utilità

Strumenti aggiuntivi disponibili dal menu Draft → Utilità o tramite il menu di scelta rapida visualizzato facendo clic con il pulsante destro del mouse, a seconda dell'oggetto selezionato.

Preferenze

  • Preferences-draft.svg Preferenze: preferenze generali per il piano di lavoro e gli strumenti di disegno.
  • Preferences-import-export.svg Preferenze Import-Export: preferenze disponibili per l'importazione e l'esportazione in diversi formati di file.

Formato dei file

Il modulo Draft fornisce a FreeCAD gli importatori e gli esportatori per i seguenti formati di file:

Ulteriori funzioni

  • Digitare le coordinate: permette di inserire le coordinate invece di fare clic sulla vista 3D per definire un nuovo punto.
  • Vincolare: limita il puntatore nei movimenti orizzontali o verticali rispetto a un punto precedente.
  • Ancorare (Snap): posiziona nuovi punti su posti speciali su oggetti esistenti o sulla griglia.

Script

Gli strumenti di Draft possono essere utilizzati nelle macro e dalla console Python utilizzando le API Draft.

Tutorial

Arrow-left.svg Workbench Arch.svg Arch Pagina precedente:
Pagina successiva: Drawing Workbench Drawing.svg Arrow-right.svg

Script e Macro

Arrow-left.svg I menu standard Pagina precedente:
Pagina successiva: Introduzione a Python Arrow-right.svg

Introduzione

Le macro sono un modo pratico per riprodurre delle azioni complesse. In FreeCAD è sufficiente registrare le azioni così come vengono eseguite, quindi salvare queste azioni con un nome, per poterle ripetere quando si vuole. Dato che le macro sono in realtà un elenco di comandi Python, è anche possibile modificarle e creare degli script molto complessi.

Sebbene gli script Python abbiano normalmente l'estensione .py, le macro di FreeCAD dovrebbero avere l'estensione .FCMacro. Una raccolta di macro scritte da utenti esperti si trova nella pagina esempi di macro.

Vedere la pagina Introduzione a Python per conoscere il linguaggio di programmazione Python, e poi Guida agli Script Python e Script di base per FreeCAD per imparare a scrivere delle macro.

Come funzionano

Quando dal menu Modifica → Preferenze → Generale → Macro → Mostra comandi script nella console python, si attiva l'output nella console si vede che ogni azione che si compie, come ad esempio la pressione di un pulsante, invia un comando Python. Questi comandi sono ciò che è possibile registrare in una macro. Lo strumento principale per creare una macro è la barra degli strumenti macro: Macros toolbar.jpg. Su di essa si trovano 4 tasti: Registrare, Interrompere la registrazione, Modificare e Riprodurre la macro corrente.

È molto semplice da usare: premere il pulsante di registrazione, dare un nome alla macro, quindi eseguire alcune azioni. Al termine, fare clic sul pulsante Interrompi registrazione, e le azioni compiute vengono salvate. Ora è possibile accedere alla finestra di dialogo delle macro utilizzando il pulsante Modifica,

Macros.png

Finestra di dialogo Macro, che elenca le macro disponibili nel sistema


Quì è possibile gestire le macro, eliminarle, duplicarle, installarle, modificarle o crearne di nuove partendo da zero. Quando si modifica una macro, essa viene aperta in una finestra dell'editor in cui è possibile apportare le proprie modifiche al codice. È possibile installare delle nuove macro utilizzando il pulsante Addons ..., che collega al Addon Manager.

Esempio

Premere il pulsante di registrazione, fornire un nome, ad esempio, "cilindro 10x10", poi, nell'Ambiente Parte, creare un cilindro con raggio = 10 e altezza = 10. Quindi, premere il pulsante "Interrompi registrazione". Nella finestra di dialogo Modifica macro, è possibile vedere il codice python che è stato registrato, e, volendo, apportarvi delle modifiche. Per eseguire la macro, è sufficiente premere sul pulsante Esegui della barra degli strumenti, mentre la macro è nell'editor. La macro viene sempre salvata su disco, in modo che tutte le modifiche apportate, o ogni nuova macro creata, sono sempre disponibili al successivo avvio di FreeCAD.

Personalizzazione

Naturalmente non è pratico dover caricare una macro nell'editor per poterla utilizzare. FreeCAD fornisce modi migliori per usarle, come ad esempio l'assegnazione ad essa di una scorciatoia da tastiera o l'inserimento di una voce nel menu. Dopo aver creato la macro, tutto questo può essere fatto tramite il menu Strumenti → Personalizza.

Macros config.jpg

Personalizzare la barra degli strumenti. In questo modo si può trasformare la macro in un vero e proprio strumento, proprio come qualsiasi strumento standard di FreeCAD. Questo, sommato alla potenza degli script Python all'interno di FreeCAD, permette di aggiungere facilmente all'interfaccia dei propri strumenti. Per maggiori informazioni sugli script Python, continuare la lettura alle pagine del Centro utenti esperti o degli Script

Creare delle macro senza registrarle

Come installare le macro. È anche possibile inserire direttamente con copia/incolla del codice python in un macro, senza registrare le azioni della GUI (dell'interfaccia grafica). È sufficiente creare una nuova macro, modificarla, e incollare il codice. È quindi possibile salvare la macro nello stesso modo in cui si salva un documento di FreeCAD. Al prossima avvio di FreeCAD, la macro viene visualizzata in "Macro installate" nel menu Macro.

Repositorio di macro

Visitare la pagina degli esempi di macro per trovare alcune utili macro da aggiungere alla propria installazione di FreeCAD.

Link

Installare ulteriori ambienti

Tutorial

Come installare ambienti di lavoro aggiuntivi.

Arrow-left.svg I menu standard Pagina precedente:
Pagina successiva: Introduzione a Python Arrow-right.svg


Arrow-left.svg Macro Pagina precedente:
Pagina successiva: Guida agli script Python Arrow-right.svg
(Novembre 2018) FreeCAD è stato originariamente progettato per funzionare con Python 2. Molte funzioni funzionano con Python 3, ma altre no. È in corso un lavoro per fare in modo che FreeCAD supporti pienamente Python 3. Qui le informazioni descrivono Python 2, ma la maggior parte del codice dovrebbe funzionare allo stesso modo con Python 3. In particolare, la funzione print() è preferita rispetto alla vecchia print.


Questo è una breve guida realizzata per chi si avvicina per la prima volta a Python. Python è un linguaggio di programmazione multi-piattaforma open-source. Python dispone di numerose funzionalità che lo rendono molto diverso dagli altri comuni linguaggi di programmazione, ed è facilmente accessibile ai nuovi utenti:

  • È stato progettato appositamente per essere letto facilmente dalle persone, quindi è molto facile da imparare e da capire.
  • È interpretato, ciò significa che, a differenza dei linguaggi compilati come il C, non è necessario compilare il programma prima di poterlo eseguire. Quando si desidera, il codice che si scrive può essere eseguito immediatamente, riga dopo riga. Siccome si procede gradualmente, passo dopo passo, è facile impararlo e trovare gli eventuali errori nel codice.
  • Può essere incorporato in altri programmi per essere usato come linguaggio di script. FreeCAD ha un interprete Python integrato, così, in FreeCAD, è possibile scrivere dei codici Python che manipolano parti di FreeCAD, ad esempio per creare la geometria. Questo è estremamente performante, perché invece di premere semplicemente un pulsante denominato "Crea sfera", che un programmatore ha messo a disposizione, si ha la libertà di creare facilmente dei propri strumenti per produrre una particolare geometria desiderata.
  • È estensibile. Si possono inserire facilmente dei nuovi moduli nella propria installazione di Python ed estenderne le funzionalità. Ad esempio, esistono moduli Python che permettono di leggere e scrivere le immagini jpg, di comunicare con Twitter, di programmare le operazioni del proprio sistema operativo, ecc.

Ora, mettiamoci al lavoro! Ricordare che ciò che verrà dopo è solamente una semplice introduzione e non un tutorial completo. Ma la speranza è che dopo si avranno basi sufficienti per esplorare più in profondità i meccanismi di FreeCAD.

L'interprete

Di solito, per scrivere programmi per computer, basta aprire un editor di testo (o l'ambiente di programmazione preferito che, in genere, è un editor di testo con strumenti aggiuntivi), scrivere il programma, quindi compilarlo ed eseguirlo. Il più delle volte si fanno degli errori di scrittura, per cui il programma non funziona, e si ottiene un messaggio di errore che dà informazioni su cosa è andato storto. Quindi si ritorna all'editor di testo, si correggono gli errori, si esegue di nuovo, e così via fino a quando il programma funziona bene.

In Python, l'intero processo, può essere eseguito in modo trasparente all'interno del suo interprete. L'interprete Python è una finestra con un prompt dei comandi, dove si può digitare direttamente il codice Python. Se si installa Python sul ​​proprio computer (scaricarlo dal sito web di Python se lavorate su Windows o Mac, installarlo dal repository dei pacchetti se utilizzate GNU/Linux), si avrà un interprete Python nel menu di avvio. FreeCAD dispone di un proprio interprete Python visualizzato nella sua finestra inferiore:

Screenshot pythoninterpreter.jpg

Se non è visibile, cliccare su Visualizza → Viste → Console Python.

L'interprete mostra la versione di Python, quindi il simbolo >>>, che è il suo prompt dei comandi, cioè, dove si deve inserire il codice Python. Scrivere il codice nell'interprete è semplice: ogni riga è una istruzione. Quando si preme Invio, la riga di codice viene eseguita (dopo essere stata istantaneamente e invisibilmente compilata). Ad esempio, provare a scrivere questo:

print "hello"

per Python print è una speciale parola chiave che, ovviamente, serve per stampare qualcosa sullo schermo. Quando si preme Invio, l'operazione viene eseguita, e viene stampato il messaggio "ciao". Se si commette un errore, provare, per esempio, a scrivere:

print hello

Python dice che non conosce ciao. I caratteri " " specificano che il contenuto è una stringa. In gergo tecnico, una stringa è semplicemente un pezzo di testo. Senza i segni ", la parola ciao viene vista come una specificazione del comando di stampa, cioè come una speciale parola chiave di Python, e non come un testo. Il fatto importante è che l'errore viene immediatamente notificato. Premendo la freccia verso l'alto (o, nell'interprete di FreeCAD, CTRL + freccia su), si può tornare all'ultimo comando scritto e correggerlo.

L'interprete Python possiede anche un sistema di aiuto incorporato. Provare a digitare:

help

oppure, ad esempio, se non si riesce a capire cosa è andato storto con il precedente comando print ciao, e si desiderano delle informazioni specifiche sul comando "print" digitare:

help("print")

Si ottiene una lunga e completa descrizione di tutto quello che può fare il comando print.

Ora che si ha il controllo totale dell'interprete, si può cominciare con le cose significative.

Variabili

Naturalmente, stampare "ciao" non è molto interessante. Più interessante è stampare cose che non si conoscono prima, o lasciare che Python le trovi per noi. Qui entra in gioco il concetto di variabile. Una variabile è semplicemente un valore che viene memorizzato con un nome specifico. Ad esempio, digitare questo:

a = "hello"
print a

Sicuramente si capisce quello che succede, la stringa "ciao" viene "salvata" sotto il nome "a". Ora, "a" non è più un nome sconosciuto! Si può usare ovunque, per esempio nel comando print. È possibile utilizzare qualsiasi nome che si desideri, basta rispettare alcune semplici regole, tipo non usare spazi o segni di punteggiatura. Ad esempio, si potrebbe tranquillamente scrivere:

hello = "my own version of hello"
print hello

Visto? ciao ora non è più una parola indefinita. E se, per sfortuna, si sceglie un nome che in Python esiste già? Supponiamo di voler conservare una stringa con il nome "print":

print = "hello"

Python è molto intelligente e ci dice che questo non è possibile. Possiede alcune parole chiave "riservate" che non possono essere modificate. Invece le nostre variabili possono essere modificate in qualsiasi momento, il che è esattamente il motivo per cui sono chiamate variabili, ovvero il contenuto può variare. Ad esempio:

myVariable = "hello"
print myVariable
myVariable = "good bye"
print myVariable

Il valore di myVariable è stato cambiato. Le variabili possono anche essere copiate:

var1 = "hello"
var2 = var1
print var2

Notare che è importante dare alle variabili dei nomi descrittivi. Quando si scrivono programmi lunghi, dopo un po' probabilmente non si ricorda più cosa rappresenta la variabile denominata "a". Se invece viene chiamata, ad esempio, MioMessaggioDiBenvenuto, quando la si vede, si capisce facilmente a cosa serve. In più è un passo avanti verso l'autodocumentazione del proprio codice.

La differenza tra maiuscole e minuscole è molto importante. myVariable non è uguale a myvariable, la differenza è tra v maiuscola e minuscola. Se si inserisce "print myvariable", viene restituito un errore non definito.

Numeri

È noto che la programmazione serve per trattare ogni tipo di dati, non solo le stringhe di testo, ma soprattutto i numeri. È molto importante che Python sappia che tipo di dati deve trattare. Nell'esempio precedente, con print ciao, si è visto che il comando print ha riconosciuto la nostra stringa "ciao". Questo perché utilizzando il segno ", abbiamo specificato al comando print che ciò che seguiva era una stringa di testo.

Per controllare in qualsiasi momento di quale tipo sono i dati contenuti in una variabile si utilizza la speciale parola chiave di Python type():

myVar = "hello"
type(myVar)

In questo caso ci dice che il contenuto di myVar è 'str', ovvero una stringa in gergo Python. Ci sono anche altri tipi di dati, ad esempio i numeri interi (integer) e i numeri in virgola mobile (float numbers):

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

Questo è già molto più interessante, vero? Ora si dispone di una potente calcolatrice! Notare bene come funziona. Python capisce che 10 e 20 sono numeri interi, quindi vengono memorizzati come "int", e con essi Python può fare tutte le operazioni consentite con numeri interi. Osservare i risultati di questo codice:

firstNumber = "10"
secondNumber = "20"
print firstNumber + secondNumber

Visto? Python è stato indotto a considerare le due variabili non più come numeri, ma come semplici parti di testo. Python può unire insieme due parti di testo, ma con esse non cerca di produrre una somma. Torniamo ai numeri. Oltre ai numeri interi (int) ci sono anche i numeri in virgola mobile (float). I numeri interi non hanno una parte decimale, mentre i numeri float possono avere una parte decimale:

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

I numeri Int e Float possono essere mescolati tra di loro senza problemi:

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

Naturalmente il totale ha dei decimali, vero? Quindi Python ha deciso automaticamente che il risultato è un float. In molti casi, come in questo, Python decide automaticamente il tipo da usare. In altri casi no. Ad esempio con:

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

Si produce un errore, varA è una stringa e varB è un int, quindi Python non sa cosa fare. Ma possiamo indurre Python a convertire i tipi:

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

Ora entrambi sono stringhe, e l'operazione funziona! Notare che, con questi comandi, varB è convertita in "stringa" solo al momento della stampa, però varB originale non viene modificata. Per trasformare varB permanentemente in una stringa, si deve fare:

varB = str(varB)

Inoltre è possibile usare int() e float() per convertire in int e in float:

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

Note sui comandi Python

Sicuramente avete notato che in questa sezione il comando di stampa (print) è stato utilizzato in diversi modi. Abbiamo stampato variabili, somme, parti separati da virgole, e anche il risultato di altri comandi Python, ad esempio type(). Forse avete anche notato che questi due comandi,

type(varA)
print type(varA)

producono esattamente lo stesso risultato. Questo succede perché siamo nell'interprete, dove ogni cosa viene sempre automaticamente stampata sullo schermo. Per velocizzare, d'ora in avanti si può fare a meno di usarlo e quindi scrivere semplicemente:

myVar = "hello friends"
myVar

Inoltre avrete notato che con la maggior parte dei comandi (o parole chiave) di Python si usano le parentesi per dire loro su quale contenuto devono operare: type(), int(), str(), ecc. Unica eccezione è il comando print, ma in realtà non si tratta di un'eccezione, anche lui funziona normalmente in questo modo:

print ("ciao")

però, siccome viene utilizzato frequentemente, i programmatori di Python ne hanno creato una versione semplificata.

Liste

Un altro tipo di dati interessante è una list (lista). Una lista è semplicemente un elenco di altri dati. In modo analogo a come si definisce una stringa di testo usando " ", una lista si definisce usando []:

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

Come si vede, una lista può contenere dati di qualsiasi tipo. Le liste sono molto utili perché permettono di raggruppare le variabili. Con il gruppo, successivamente, è possibile fare diverse cose, ad esempio contare i suoi componenti:

len(myOtherList)

o recuperare un elemento da una lista:

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

Come si vede, mentre il comando len() restituisce il numero totale di elementi in una lista, la loro "posizione" nella lista inizia con 0. Il primo elemento in una lista si trova sempre in posizione 0, quindi nella lista myOtherList, "Bob" è nella posizione 2. Con le liste è possibile eseguire molte altre operazioni, descritte in modo più completo qui, ad esempio, ordinare i suoi contenuti, rimuovere o aggiungere elementi.

Una cosa curiosa: una stringa di testo è molto simile a una lista di caratteri! Provate a fare questo:

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

In genere, tutto quello che si può fare con le liste si può fare anche con le stringhe. In effetti le liste e le stringhe sono entrambe delle sequenze.

Oltre a stringhe, int, float e liste, in Python sono disponibili molti altri tipi di dati built-in (incorporati), quali ad esempio i dictionaries (collezione di oggetti), oppure si possono creare dei propri tipi di dati utilizzando le classi.

Indentazione

Un tipico uso della lista consiste nel navigare al suo interno e di operare con i suoi elementi. Per esempio osservare questo:

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

In questo esempio, la lista viene iterata (nuovo gergo di programmazione!) con il comando "for ... in ..." e con ognuno dei suoi elementi viene eseguito qualcosa.

Notare la speciale sintassi. Il comando "for" termina con un ":" questo indica a Python che ciò che segue è un blocco di uno o più comandi. Subito dopo che viene inserita la riga con il comando che termina con :, il prompt dei comandi cambia in ... il che significa che Python ha riconosciuto un comando terminato con un (:) e quello che segue è parte del comando stesso.

Come fa Python a sapere quante delle prossime righe sono da eseguire all'interno dell'operazione for ... in ? Per sapere questo, Python utilizza l'indentazione. Cioè, le righe successive non iniziano immediatamente, ma iniziano con uno o più spazi vuoti, oppure con uno o più spazi di tabulazione. Altri linguaggi di programmazione utilizzano vari metodi, tipo inserire tutto dentro parentesi, ecc. Finché le righe successive sono scritte con la stessa indentazione, esse sono considerate come parte del blocco for-in. Quando si inizia una riga con 2 spazi vuoti e quella successiva con 4, si produce un errore. Per terminare e uscire dal blocco for-in, basta scrivere una nuova riga senza rientro, o semplicemente premere Invio.

L'indentazione è molto utile perché conferisce leggibilità al promma. Se è ampia (usando, ad esempio, tab che crea più spazi invece di un solo), quando si scrive un programma lungo si ha una visione chiara di ciò che viene eseguito all'interno di ogni blocco. Vedremo che anche molti altri comandi diversi da for-in richiedono blocchi indentati.

Il comando for-in può essere utilizzato per varie operazioni che devono essere eseguite più volte. Ad esempio, può essere combinato con il comando range():

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

Per usare i decimali in un loop range.

If you would type into the interpreter help(range) you would see:

range(...)
    range(stop) -> list of integers
    range(start, stop[, step]) -> list of integers

Here the square brackets denote an optional parameter. However all are expected to be integers. Below we will force the range parameters to be an integer using int()

decimales = 1000                     # for 3 decimales 
#decimales = 10000                   # for 4 decimales ...
for i in range(int(0 * decimales),int(180 * decimales),int(0.5 * decimales)):
    print float(i) / decimales

O per operazioni più complesse tipo questa:

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

Come si vede, anche il comando range() ha la strana particolarità di iniziare con 0 (quando non si specifica il numero di partenza) e che il suo ultimo numero è uno in meno del numero finale specificato. Ciò, naturalmente, perché questo modo funziona bene con gli altri comandi di Python. Ad esempio:

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

Un altro uso interessante dei blocchi indentati si ha con il comando if. Il comando if esegue un blocco di codice solo se una certa condizione è soddisfatta, ad esempio:

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

Naturalmente, questo esempio stampa sempre la prima frase, ma provare a sostituire la seconda riga con:

if "Lucky" in alldaltons:

Ora non viene più stampato nulla. Si può anche specificare una dichiarazione: else:

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

Funzioni

I comandi standard di Python non sono molti. Nella versione corrente di Python ce ne sono circa 30, e ne conosciamo già alcuni di loro. Ma immaginate se potessimo inventare dei nostri propri comandi? Beh, possiamo, ed è estremamente facile. In effetti, la maggior parte dei moduli aggiuntivi che si possono aggiungere nella propria installazione di Python fanno esattamente questo, essi aggiungono dei comandi utilizzabili. In Python un comando personalizzato si chiama funzione e si crea in questo modo:

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

Estremamente semplice: il comando def() definisce una nuova funzione. Si può dargli un nome, e dentro la parentesi si definiscono gli argomenti che useremo nella nostra funzione. Gli argomenti sono i dati che verranno passati alla funzione.

Ad esempio, osservare il comando len(). Se si scrive semplicemente len() da solo, Python vi dice che ha bisogno di un argomento. Cioè, si vuole len() di qualcosa. Quindi, ad esempio, bisogna scrivere len(myList) per ottenere la lunghezza di myList. Bene, myList è un argomento che viene passato alla funzione len(). La funzione len() è definita in modo da sapere come utilizzare ciò che gli viene passato. Esattamente come si è appena fatto qui.

Estremamente semplice: il comando def() definisce una nuova funzione. Si può dargli un nome, e dentro la parentesi si definiscono gli argomenti che useremo nella nostra funzione. Gli argomenti sono i dati che verranno passati alla funzione.

Ad esempio, osservare il comando len(). Se si scrive semplicemente len() da solo, Python vi dice che ha bisogno di un argomento. Cioè, si vuole len() di qualcosa. Quindi, ad esempio, bisogna scrivere len(myList) per ottenere la lunghezza di myList. Bene, myList è un argomento che viene passato alla funzione len(). La funzione len() è definita in modo da sapere come utilizzare ciò che gli viene passato. Esattamente come si è appena fatto qui.

Il nome "myValue" può contenere qualsiasi oggetto, e viene utilizzato solo all'interno della funzione. È solo un nome assegnato all'argomento in modo da poter operare con esso, però serve anche a fare in modo che la funzione sappia quanti argomenti aspettarsi. Se, ad esempio, si esegue:

printsqm(45,34)

Si ottiene un errore. La funzione è stata programmata per ricevere un solo argomento, ma ne ha ricevuto due, 45 e 34. In sostituzione, si può eseguire qualcosa di simile a:

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

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

Dove si crea una funzione che riceve due argomenti, li somma, e restituisce il valore. Ottenere qualcosa è molto utile, perché permette di utilizzare il risultato ottenuto e, ad esempio, memorizzarlo nella variabile myTotal. Naturalmente, visto che siamo nell'interprete e tutto quello che facciamo viene stampato, digitando:

sum(45,34)

il risultato viene stampato sullo schermo, ma al di fuori dell'interprete, e, siccome non vi è alcun comando di stampa all'interno della funzione, sullo schermo non appare nulla. Per ottenere la stampa, si deve digitare:

print sum(45,34)

Per ulteriori informazioni sulle funzioni leggere qui.

Moduli

Ora che si ha un'idea di come funziona Python, serve una ultima cosa: Come lavorare con i file e i moduli.

Fino ad ora, abbiamo scritto le istruzioni nell'interprete di Python riga per riga, vero?

Quando si intende fare delle cose più complesse, è certamente più comodo scrivere prima diverse righe di codice, e poi eseguirle tutte insieme in una unica volta. Bene, anche questo, è estremamente facile da farsi, e inoltre permette anche salvare il proprio lavoro.

È sufficiente aprire un editor di testo (ad es. il Blocco Note di Windows, o gedit, emacs, o vi per Linux), e scrivere tutte le proprie righe di Python, nello stesso modo in cui si scrivono nell'interprete, con indentazioni, ecc. Quindi, salvare il file da qualche parte, preferibilmente con estensione .py. Tutto qui, ora si dispone di un programma Python completo. Naturalmente, ci sono editor migliori di notepad, citato solo per dimostrare che un programma Python non è altro che un file di testo.

Per far eseguire questo programma da Python, ci sono centinaia di modi. In Windows, è sufficiente fare clic sul file, aprirlo con Python, ed eseguirlo. Ma si può anche eseguire con l'interprete di Python stesso. Per fare questo, l'interprete deve sapere dove si trova il programma .py. In FreeCAD, il modo più semplice è quello di inserire il programma in un luogo che l'interprete Python di FreeCAD conosce di default, quale, ad esempio, la cartella bin di FreeCAD, o una qualsiasi delle cartelle Mod. (In Linux, si ha probabilmente una directory /home/<username>/.FreeCAD/Mod, aggiungiamo una sottodirectory a quegli script richiamati dove inseriremo il file di testo.) Supponiamo di scrivere questo file:

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

print "myTest.py succesfully loaded"

e di salvarlo con il nome MioTest.py nella nostra directory /bin di FreeCAD (o on Linux to /home/<username>/.FreeCAD/Mod/scripts). Ora, avviamo FreeCAD e nella finestra interprete scriviamo:

import myTest

senza l'estensione. py. Questo comando esegue semplicemente il contenuto del file, riga per riga, esattamente come quando viene scritto nell'interprete. Viene creata la funzione somma, poi viene stampato il messaggio. Però c'è una grande differenza: il comando di importazione (import) serve non solo per eseguire i programmi contenuti in un file, come il nostro, ma anche per caricare le funzioni interne, in modo da renderle disponibili nell'interprete. I file, come il nostro, contenenti funzioni sono chiamati moduli.

Di solito, come si è fatto in precedenza, quando si scrive la funzione sum() nell'interprete, si digita semplicemente:

sum(14,45)

Invece, quando si importa un modulo contenente una funzione sum(), la sintassi è un po' diversa. Si scrive:

myTest.sum(14,45)

Cioè, il modulo viene importato come un "contenitore", e tutte le sue funzioni sono all'interno. Dato che è possibile importare più moduli, ciò è estremamente utile per tenere il tutto ben organizzato. In sostanza, quando si vede "qualcosa.qualcosaAltro", con un punto in mezzo, significa che "qualcosaAltro" è contenuto in "qualcosa".

Si può anche estrarre da test una sua parte, e importare la funzione sum() direttamente nello spazio principale dell'interprete, in questo modo:

from myTest import *
sum(12,54)

In pratica tutti i moduli si comportano in questo modo. È possibile importare un modulo, e poi utilizzare le sue funzioni tramite l'istruzione: module.function (argomento). Quasi tutti i moduli eseguono le seguenti operazioni: definiscono le funzioni, i nuovi tipi di dati e le classi che è possibile utilizzare nell'interprete o nei moduli Python, perché nulla impedisce di importare altri moduli all'interno di un proprio modulo!

Un'ultima cosa estremamente utile. Come si fa per sapere quali moduli sono disponibili, quali funzioni sono al loro interno e come usarli (cioè, di che tipo di argomenti hanno bisogno)? Si è già visto che Python ha una funzione help(). Digitare:

help()
modules

Viene restituito un elenco di tutti i moduli disponibili. Digitare q per uscire dall'aiuto interattivo e importare qualsiasi di essi.

Si può anche sfogliare il contenuto del modulo tramite il comando dir():

import math
dir(math)

In questo caso, si vedono tutte le funzioni contenute nel modulo di matematica (il modulo math), come, ad esempio, cose con strani nomi __ doc__, __ FILE__, __ name__. L'oggetto doc__ __ è estremamente utile, è un testo di documentazione. Ogni funzione dei moduli (se fatti bene) ha un proprio __doc__ che spiega come usarla. Se, per esempio, si vuole sapere come usare la funzione sin (seno) contenuta all'interno del modulo math, basta digitare:

print math.sin.__doc__

(Potrebbe non essere evidente, ma su entrambi i lati del doc ci sono due caratteri di sottolineatura.)

E infine un ultimo piccolo omaggio: quando lavoriamo su un modulo nuovo o esistente, è meglio sostituire l'estensione del file con py come: myModule.FCMacro => myModule.py. Spesso vogliamo testarlo, quindi lo caricheremo come sopra.

import myModule
myModule.myTestFunction()

Ma cosa succede se il modulo myTestFunction() non funziona correttamente? Si torna al proprio editor per modificarlo. Dopo, invece di chiudere e riaprire l'interprete python, è possibile aggiornare semplicemente il modulo in questo modo:

reload(myModule)

Questo perché Python non conosce l'estensione FCMacro.

Però, si può fare in due modi: 1. Utilizzare una funzione exec o execfile di Python all'interno della macro.

f = open("myModule","r")
d = f.read()
exec d

oppure

execfile "myModule"

Per Python 3.xxx sostituire questo codice con:

exec(open("C:/PathToMyMacro/myMacro.FCMacro").read())

Per condividere il codice tra le macro, è possibile ad esempio accedere al modulo FreeCAD o FreeCADGui (o qualsiasi altro modulo Python) e impostare qualsiasi attributo ad esso. Questo dovrebbe sopravvivere alla esecuzione della macro.

import FreeCAD
if hasattr(FreeCAD,"macro2_executed"):
    ...
else:
    FreeCAD.macro2_executed = True # you can assign any value because we only check for the existence of the attribute
    ... execute macro2

Iniziare con FreeCAD

Ora che si ha un'idea di come funziona Python si può iniziare ad esplorare quello che FreeCAD ha da offrire. Le funzioni Python di FreeCAD sono tutte ben organizzate in moduli diversi. Alcuni di loro vengono caricati (importati) all'avvio di FreeCAD. Quindi, basta solo, digitare:

dir()

e continuate a leggere in Script base in FreeCAD.

Naturalmente, quì si è visto solo una parte molto piccola del mondo di Python. Ci sono ancora molti altri concetti importanti che non sono stati menzionati qui.

In rete sono disponibili tre documenti molto importanti che referenziano Python:

Accertarsi di averli nel segnalibri!


Arrow-left.svg Macro Pagina precedente:
Pagina successiva: Guida agli script Python Arrow-right.svg


Arrow-left.svg Guida agli script Python Pagina precedente:
Pagina successiva: Script per Mesh Arrow-right.svg

Script Python in FreeCAD

FreeCAD è stato costruito fin dall'inizio per essere totalmente controllato tramite gli script Python.

Quasi tutte le parti di FreeCAD, come ad esempio l'interfaccia oppure i contenuti della scena, compresa la rappresentazione di quanto contenuto nelle viste 3D, sono accessibili tramite l'interprete Python incorporato o tramite script personali.

Per questo, FreeCAD risulta probabilmente una delle applicazioni ingegneristiche più profondamente personalizzabili oggi disponibili.

Allo stato attuale, FreeCAD ha però pochissimi comandi "nativi" per interagire con gli oggetti 3D, soprattutto perché è ancora all'inizio dello sviluppo, ma anche perché i suoi programmatori intendono fornire una piattaforma base per lo sviluppo del CAD piuttosto che un'applicazione per un uso specifico.

La facilità d'uso degli script Python all'interno di FreeCAD permette di conoscere velocemente le nuove funzionalità in fase di sviluppo come "utenti esperti", cioè come utenti che conoscono un po' di programmazione Python.

Python è uno dei più popolari linguaggi interpretati, e poiché è generalmente considerato facile da imparare, anche voi potrete produrre presto vostri script all'interno di FreeCAD come "utenti esperti".

Se non conoscete ancora Python, vi consigliamo di cercare qualche tutorial su internet e di dare un rapido sguardo alla sua struttura.

Python è un linguaggio molto facile da imparare, soprattutto perché può essere eseguito all'interno di un interprete, dove sia i comandi semplici come i programmi completi, possono essere eseguiti "al volo", cioè senza bisogno di compilare nulla.

FreeCAD incorpora un interprete Python. Se non vedete la finestra denominata "Console Python" della figura successiva, potete attivarla con Visualizza → Pannelli → Console Python e mostrare l'interprete.

L'interprete

Tramite l'interprete, è possibile accedere a tutti i moduli Python installati nel sistema, come pure ai moduli incorporati in FreeCAD e a tutti i moduli aggiuntivi di FreeCAD installati successivamente.

La schermata seguente mostra l'interprete Python di FreeCAD:

The FreeCAD Python interpreter

Tramite l'interprete è possibile eseguire del codice Python e sfogliare le classi e le funzioni disponibili.

FreeCAD fornisce un browser delle classi molto utile per esplorare il nuovo mondo di FreeCAD.

Quando si digita il nome di una classe nota seguita da un punto (.) (il che significa che si intende completare aggiungendo qualcos'altro alla classe), si apre la finestra del browser delle classi, dove si può navigare tra le sottoclassi e i metodi disponibili.

Quando si seleziona una voce, viene visualizzato il testo di aiuto associato (se esiste):

The FreeCAD class browser

Per verificare questo, iniziate a digitare App. oppure Gui. e osservate cosa succede.

Generalmente, in Python, per esplorare il contenuto dei moduli e delle classi si utilizza il comando print dir().

Ad esempio, digitando print dir() si ottiene l'elenco di tutti i moduli attualmente caricati in FreeCAD e con print dir(App) si mostra tutto ciò che è contenuto all'interno del modulo App, ecc..

Inoltre l'interprete ricorda i codici che vengono digitati. Questa altra utile caratteristica dell'interprete permette di esplorare all'indietro i comandi digitati e di recuperare, attraverso la cronologia, una riga di codice scritta in precedenza.

Per navigare nella cronologia dei comandi, basta usare la combinazione di tasti CTRL+UP oppure CTRL+DOWN.

Cliccando col tasto destro nella finestra dell'interprete, si rendono disponibili diverse altre opzioni, quali, ad esempio, copiare lo storico (l'intera cronologia, cosa utile quando si desidera sperimentare qualcosa prima di utilizzarla in uno script) oppure inserire un nome di un file con il suo percorso completo.

Aiuti di Python

Nel menu Aiuto di FreeCAD, trovate una voce denominata Documentazione automatica per i moduli Python, essa apre una finestra del browser contenente una documentazione completa, generata in tempo reale, di tutti i moduli Python a disposizione dell'interprete di FreeCAD, compreso Python e i moduli interni di FreeCAD, i moduli installati dal sistema e i moduli aggiuntivi di FreeCAD.

La documentazione disponibile dipende dalla fatica che lo sviluppatore del modulo ha fatto per documentare il proprio codice. I moduli Python hanno la reputazione di essere in genere abbastanza ben documentati. La finestra di FreeCAD deve rimanere aperta perché questo sistema di documentazione funzioni.

La voce "Python Help" fornisce un collegamento rapido alla sezione wiki "User Hub".

Moduli incorporati (Built-in)

Dato che FreeCAD è stato progettato per essere eseguito senza una interfaccia grafica (GUI), quasi tutte le sue funzionalità sono divise in due parti: la funzionalità di base, denominata App, e la funzionalità grafica, denominata Gui. Per questo motivo i due principali moduli incorporati nel nostro FreeCAD sono chiamati App e Gui. Questi due moduli sono accessibili, rispettivamente con il nome "FreeCAD" e "FreeCADGui", anche tramite script eseguiti al di fuori dell'interprete.

  • Nel modulo App, si trova tutto ciò che riguarda l'applicazione stessa, cioè i metodi per l'apertura o la chiusura di file e documenti, oppure l'impostazione del documento attivo o la visualizzazione dei contenuti.
  • Nel modulo Gui, si trovano gli strumenti per accedere e gestire gli elementi dell'interfaccia grafica (GUI), cioè gli ambienti di lavoro e le loro barre degli strumenti e, più interessante, la rappresentazione grafica di tutti i contenuti di FreeCAD.

Elencare tutto il contenuto di tali moduli è un lavoro un po' controproducente, in quanto essi crescono molto velocemente seguendo lo sviluppo di FreeCAD.

I due strumenti di esplorazione disponibili (il browser delle classi e l'aiuto di Python) dovrebbero dare, in qualsiasi momento, una completa e aggiornata documentazione di questi moduli.

Gli oggetti App e gli oggetti GUI

Come abbiamo detto, in FreeCAD, tutto viene separato tra nucleo e rappresentazione. Ciò vale anche per gli oggetti 3D.

È possibile accedere alla definizione delle proprietà degli oggetti (chiamate funzioni in FreeCAD) tramite il modulo App, e cambiare il modo in cui gli oggetti vengono riprodotti sullo schermo tramite il modulo Gui.

Ad esempio, un parallelepipedo ha delle proprietà che lo definiscono, (cioè larghezza, lunghezza e altezza) che vengono memorizzate in un oggetto App e delle proprietà di rappresentazione, (come il colore delle facce, la modalità di disegno) che sono memorizzate in un corrispondente oggetto Gui.

Questo modo di fare le cose consente una vasta gamma di operazioni, come gli algoritmi che funzionano solo sulla parte di definizione delle caratteristiche, senza la necessità di prendersi cura di nessuna parte visiva, e consente anche di reindirizzare il contenuto del documento a applicazioni non-grafiche, quali, ad esempio, elenchi, fogli di calcolo, o analisi degli elementi.

Nel documento, per ogni oggetto App, esiste un corrispondente oggetto Gui. Infatti lo stesso documento possiede sia oggetti App che oggetti Gui.

Questo, naturalmente, è valido solo quando si esegue FreeCAD completo di interfaccia grafica. Nella versione riga di comando, senza interfaccia grafica, sono quindi disponibili solo gli oggetti App.

Ricordare che la parte Gui degli oggetti viene rigenerata ogni volta che un oggetto App viene indicato "da ricalcolare" (ad esempio quando cambia uno dei suoi parametri), in quanto le modifiche fatte direttamente all'oggetto Gui potrebbero perdersi.

Per accedere alla parte App di qualcosa, si digita:

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

dove "ObjectName" è il nome del vostro oggetto.

Inoltre è possibile digitare:

myObject = App.ActiveDocument.ObjectName

Per accedere alla parte Gui dello stesso oggetto, si digita:

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

dove "ObjectName" è il nome del vostro oggetto.

Inoltre è possibile digitare:

myViewObject = App.ActiveDocument.ObjectName.ViewObject

Se non abbiamo GUI (ad esempio, siamo in modalità riga di comando), l'ultima riga non restituirà nulla.

Gli oggetti del documento

In FreeCAD tutto il vostro lavoro si trova all'interno dei documenti.

Un documento contiene la geometria e può essere salvato in un file. Si possono avere simultaneamente più documenti aperti.

Il documento, come la geometria contenuta all'interno, ha oggetti App e oggetti Gui. L'oggetto App contiene le definizioni della geometria reale, mentre l'oggetto Gui contiene i diversi punti di vista del documento.

È possibile aprire più finestre, ognuna delle quali visualizza il lavoro con un fattore di zoom o un punto di vista diverso. Questi punti di vista fanno tutti parte dell'oggetto Gui del documento.

Per accedere alla parte App del documento attualmente aperto (attivo), si digita:

myDocument = App.ActiveDocument

Per creare un nuovo documento, si digita:

myDocument = App.newDocument("Document Name")

Per accedere alla parte Gui del documento attualmente aperto (attivo), si digita:

myGuiDocument = Gui.ActiveDocument

Per accedere alla vista corrente, si digita:

myView = Gui.ActiveDocument.ActiveView

Utilizzo di moduli aggiuntivi

I moduli FreeCAD e FreeCADGui sono responsabili esclusivamente della creazione e della gestione degli oggetti nel documento di FreeCAD.

Essi in realtà non fanno nulla che riguardi la creazione o la modifica della geometria.

Ciò è dovuto al fatto che la geometria può essere di diversi tipi, e quindi la sua gestione è affidata ai moduli aggiuntivi, ognuno di essi ha il compito di gestire uno specifico tipo di geometria.

Il modulo Parte utilizza il kernel OpenCascade, e quindi è in grado di creare e manipolare geometrie di tipo B-rep, che è appunto il tipo di geometria costruito da OpenCascade.

Il modulo Mesh è in grado di costruire e modificare gli oggetti mesh.

In questo modo, FreeCAD è in grado di gestire un'ampia gamma di tipi di oggetti che possono coesistere nello stesso documento, e nuovi tipi potrebbero essere aggiunti facilmente in futuro.

Creare degli oggetti

Ogni modulo tratta la propria geometria in un modo specifico, però in genere tutti i moduli possono creare degli oggetti nel documento.

Il documento FreeCAD è anche a conoscenza dei tipi di oggetti fornibili dai moduli e il seguente comando:

FreeCAD.ActiveDocument.supportedTypes()

mostra tutti gli oggetti che si possono creare.

Come esempio, proviamo a creare un oggetto mesh (trattato dal modulo Mesh) e un oggetto parte (trattato dal modulo Part):

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

Il primo parametro è il tipo di oggetto, il secondo il nome dell'oggetto. I nostri due oggetti appaiono quasi come la stessa cosa.

Al momento, essi non contengono ancora la geometria, e se li ispezioniamo con dir(myMesh) e con dir(myPart) la maggior parte delle loro proprietà sono le stesse. L'unica differenza è che myMesh ha una proprietà "Mesh" e "Part" ha una proprietà "Shape". È qui che i dati Mesh e Parte vengono memorizzati.

Come esempio, creiamo un cubo di tipo Parte e poi lo archiviamo nel nostro oggetto myPart:

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

Se provate a memorizzare il cubo all'interno della proprietà Mesh dell'oggetto myMesh, vi verrà restituito un messaggio di "errore di tipo". Questo perché le proprietà sono fatte in modo da memorizzare solo uno specifico tipo. Nelle proprietà Mesh di myMesh, è possibile salvare solo elementi creati con il modulo Mesh.

Notare che la maggior parte dei moduli hanno anche un collegamento per aggiungere la loro geometria al documento:

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

Modificare gli oggetti

La modifica di un oggetto si esegue nello stesso modo:

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

Ora cambiamo la sua forma in una più grande:

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

Interrogare gli oggetti

È sempre possibile sapere di che tipo è un oggetto con:

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

o sapere se un oggetto è derivato da uno di quelli base (struttura di Parte, struttura di Mesh, etc) con:

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

Ora si può davvero iniziare a divertirsi con FreeCAD! Per vedere ciò che si può fare con il Modulo Parte, leggere la pagina Script per ambiente Parte, o la pagina Script per ambiente Mesh per lavorare con il Modulo Mesh.

Notare che, oltre ai moduli Parte e Mesh che sono i più completi e sono molto utilizzati, anche altri moduli come il Modulo Draft hanno script API che possono servirvi.

Per un elenco completo di tutti i moduli e gli strumenti disponibili, consultare la sezione Category:API/it.

Arrow-left.svg Guida agli script Python Pagina precedente:
Pagina successiva: Script per Mesh Arrow-right.svg



Arrow-left.svg Basi di Script in FreeCAD Pagina precedente:
Pagina successiva: Script di dati topologici Arrow-right.svg

Introduzione

Prima di tutto si deve importare il modulo Mesh:

import Mesh

Dopo questa operazione si ha accesso al modulo Mesh e alla classe Mesh che offrono le funzioni del Kernel C++ Mesh di FreeCAD.

Creazione e caricamento

Per creare un oggetto mesh vuoto basta usare il costruttore standard:

mesh = Mesh.Mesh()

Inoltre è possibile creare un oggetto da un file

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

Un elenco di tipi di file compatibili è disponibile in questa pagina al paragrafo 'Mesh'.

Oppure crearlo tramite un gruppo di triangoli descritti dai loro vertici:

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)
Mesh.show(planarMeshObject)

Il Kernel Mesh si occupa di creare una corretta struttura topologica dei dati individuando i punti e i bordi coincidenti.

Più avanti si vedrà come è possibile verificare ed esaminare i dati mesh.

Modellazione

Per creare delle geometrie regolari è possibile utilizzare lo script Python BuildRegularGeoms.py.

import BuildRegularGeoms

Questo script fornisce i metodi per definire semplici corpi di rotazione, tipo le sfere, gli ellissoidi, i cilindri, i coni e i toroidi. Inoltre ha anche un metodo per creare un semplice cubo.

Ad esempio, per creare un toroide si può fare nel modo seguente:

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

I primi due parametri definiscono i raggi del toroide e il terzo parametro è un fattore di sub-campionamento che stabilisce quanti triangoli vengono creati. Maggiore è questo valore e più il corpo è liscio, più questo valore è piccolo e più il corpo è grossolano (sfaccettato).

La classe Mesh fornisce una serie di funzioni booleane che possono essere utilizzate per operazioni di modellazione. Essa fornisce l'unione, l'intersezione e la differenza tra due oggetti mesh.

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

Ecco infine, un esempio completo che calcola l'intersezione tra una sfera e un cilindro che interseca la sfera.

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 = diff.difference(cylinder)
d = FreeCAD.newDocument()
d.addObject("Mesh::Feature","Diff_Sphere_Cylinder").Mesh=diff
d.recompute()

Analisi e Test

Scrivere i propri algoritmi

Esportazione

Si può anche scrivere l'oggetto mesh in un modulo python:

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

Aspetti correlati alla GUI

Prove

Una nutrita (anche se difficile da usare) libreria di script riferiti a Mesh sono gli script dell'unita di test del Modulo Mesh. In questa unit test sono letteralmente chiamati tutti i metodi e sono ottimizzate tutte le proprietà e gli attributi. Quindi, se siete abbastanza coraggiosi, date un'occhiata al modulo unit test.

Vedere anche Mesh API

Arrow-left.svg Basi di Script in FreeCAD Pagina precedente:
Pagina successiva: Script di dati topologici Arrow-right.svg


Arrow-left.svg Script per Mesh Pagina precedente:
Pagina successiva: Da Mesh a Parte e viceversa Arrow-right.svg

Base ExampleCommandModel.png Tutorial

Argomento
Programmazione
Livello di difficoltà
Intermedio
Tempo di esecuzione
Autore
Versione di FreeCAD
File di esempio



Questa pagina descrive i diversi metodi per creare e modificare gli oggetti di tipo Parte tramite Python.

Se non si conosce ancora Python, prima di leggere questa pagina, è meglio leggere la pagina di introduzione a Python e quella in cui si descrive come funzionano gli script in FreeCAD.

Introduzione

Qui si spiega come controllare il Modulo Parte direttamente tramite l'interprete Python di FreeCAD, o tramite degli script esterni.

Se avete bisogno di ulteriori informazioni su come funzionano gli script in FreeCAD, potete consultare la sezione Script e la sezione Concetti base sugli script in FreeCAD.

Diagramma delle classi

Questa è una panoramica delle classi Linguaggio di Modellazione Unificato (UML) più importanti del modulo Parte:

Python classes of the Part module

Geometria

Gli oggetti geometrici sono le fondamenta per la costruzione di tutti gli oggetti topologici:

  • Geom Classe base degli oggetti geometrici
  • Line Linea retta in 3D, definita dal punto iniziale e dal punto finale
  • Circle Cerchio o arco definito dal centro, dal punto iniziale e dal punto finale
  • ...... E presto ancora altro

Topologia

Sono disponibili i seguenti tipi di dati topologici:

  • compound Un gruppo di qualsiasi tipo di oggetto topologico.
  • compsolid Un solido composito è un insieme di solidi collegati dalle loro facce. E' una estensione dei concetti wire e shell ai solidi.
  • solid Una parte di spazio limitato da shell. E' tridimensionale
  • shell Una serie di facce connesse nei loro bordi. Una shell (guscio) può essere aperta o chiusa.
  • face In 2D è una parte di un piano; in 3D è una parte di una superficie. La sua geometria è vincolata (delimitata/tagliata) dai suoi bordi.
  • wire Una serie di bordi (una polilinea) collegati tra di loro nei vertici. Può essere un profilo aperto o chiuso, secondo se i bordi sono interamente concatenati oppure no.
  • edge Un elemento topologico corrispondente ad una curva limitata. Un bordo è generalmente delimitato dai vertici. Ha una dimensione.
  • vertex Un elemento topologico corrispondente ad un punto. Esso non ha dimensioni.
  • shape Un termine generico che comprende tutti i precedenti.

Veloce esempio: Creare una topologia base

Wire


Creeremo ora una topologia tramite la costruzione della semplice geometria. Come caso di studio, utilizzeremo una forma come quella che si vede nella figura, composta da quattro vertici, due cerchi e due linee.

Creare la geometria

Per prima cosa dobbiamo creare le singole parti geometriche di questo contorno (wire). È necessario che i vertici delle parti geometriche siano nella stessa posizione. In caso contrario, in seguito potremmo non essere in grado di collegare le parti geometriche in una topologia!

Quindi creiamo prima i punti:

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


Per creare un arco di cerchio prima creiamo un punto di supporto poi creiamo l'arco di cerchio tramite tre punti:

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)

Linea

Line


La linea (segmento) può essere creata molto semplicemente tramite i punti:

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

Nota: in FreeCAD 0.16 è stato utilizzato Part.Line, per FreeCAD 0.17 deve essere utilizzato Part.LineSegment

Unire tutto

L'ultimo passaggio consiste nell'unire tutti gli elementi geometrici di base e produrre una forma topologica:

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

Creare un prisma

Ora si può estrudere il contorno nella direzione voluta e creare una forma 3D reale:

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

Mostrare il risultato

Part.show(P)

Creare forme di base

Con i metodi "make...()" del Modulo Parte è possibile creare facilmente oggetti topologici di base (chiamati anche forme primitive). Ad esempio, si può creare un cubo con:

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

Altri metodi make...() disponibili sono:

  • makeBox(l,w,h) -- Produce un box situato in p e rivolto nella direzione d con le dimensioni (l,w,h)
  • makeCircle(raggio) -- Crea un cerchio con un raggio dato
  • makeCone(raggio1,raggio2,altezza) -- Restituisce un cono con raggio e altezza dati
  • makeCylinder(raggio,altezza) -- Crea un cilindro con raggio e l'altezza prestabilite
  • makeLine((x1,y1,z1),(x2,y2,z2)) -- Crea una linea tra due punti
  • makePlane(lunghezza,larghezza) -- Crea un piano con lunghezza e larghezza
  • makePolygon(lista) -- Restituisce un poligono da una serie di punti
  • makeSphere(raggio) -- Crea una sfera di raggio dato
  • makeTorus(raggio1,raggio2) -- Crea un toro con raggi determinati

Per avere un elenco completo dei metodi disponibili con il modulo Parte consultare la pagina API di Parte (Part API in inglese).

Importare i moduli necessari

In primo luogo è necessario importare il modulo Parte per poter utilizzare i suoi contenuti in Python. Inoltre, importiamo anche il modulo Base dall'interno del modulo FreeCAD:

import Part
from FreeCAD import Base

Creare un vettore

Per la costruzione di forme, i Vettori sono una delle parti di informazione più importanti. Di solito, ma non necessariamente sempre, essi contengono 3 numeri che sono le coordinate cartesiane x, y e z. È possibile creare un vettore nel modo seguente:

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

Abbiamo appena creato un vettore nelle coordinate x=3, y=2, z=0. Nel modulo Parte, i vettori sono usati in tutte le parti. Le forme Parte usano anche un altro tipo di rappresentazione del punto, chiamato Vertex (Vertice), che in realtà non è altro che un contenitore per un vettore. Si accede al vettore di un vertice in questo modo:

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

Creare un bordo

Un bordo non è altro che una linea con due vertici:

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

Nota: È anche possibile creare un bordo passando due vettori:

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

È possibile trovare la lunghezza e il centro di un bordo in questo modo:

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

Mostrare la forma sullo schermo

Con le operazioni precedenti abbiamo creato un oggetto bordo, ma esso non è visibile da nessuna parte sullo schermo. Questo perché la scena 3D di FreeCAD mostra solo quello che gli si chiede di visualizzare. Per farlo, usiamo questo semplice metodo:

Part.show(edge)

La funzione show crea un oggetto nel nostro documento FreeCAD e gli assegna la forma "edge". Utilizzare questo metodo ogni volta che si vuole visulizzare il proprio prodotto sullo schermo.

Creare un contorno

Un contorno è una polilinea e può essere creato da una serie di bordi o anche da una serie di contorni:

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) serve per visualizzare i 4 bordi che compongono il nostro contorno. Si possono facilmente recuperare altre informazioni utili con:

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

Creare una faccia

Sono valide solo le facce create da contorni chiusi. Nell'esempio, wire3 è un contorno chiuso, ma wire2 non è un contorno chiuso (vedi esempio precedente)

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

Solamente le facce hanno un'area, non i contorni né i bordi.

Creare una circonferenza

Un cerchio può essere creato in questo semplice modo:

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

Se si vuole crearlo in una determinata posizione e con una direzione prestabilita:

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 verrà creato a distanza 10 dall'origine di x e sarà rivolto verso l'asse x. Nota: makeCircle accetta solo Base.Vector() per la posizione e le normali, ma non tuple. È inoltre possibile creare una parte di cerchio fornendo un angolo iniziale e un angolo finale come:

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)

Unendo arc1 con arc2 (sono due semicerchi) si ottiene un cerchio completo. Gli angoli devono essere forniti in gradi; se avete angoli in radianti convertirli usando semplicemente la formula: gradi = radianti * 180/PI o utilizzando il modulo matematico di Python (ovviamente, dopo aver importato il modulo math):

degrees = math.degrees(radians)

Creare un arco attraverso dei punti

Purtroppo, per creare un arco lungo tre punti non esiste una funzione makeArc ma si deve usare la funzione Part.Arc. Fondamentalmente si può pensare come un arco che unisce il punto iniziale e finale passando per il punto medio. Part.Arc crea un oggetto arco nel quale deve essere chiamato .toShape() per ottenere un oggetto bordo, allo stesso modo di quando si usa Part.LineSegment al posto di 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 accetta solo punti Base.Vector(), ma non tuple. arc_edge è ciò che vogliamo e che possiamo visualizzare con Part.show(arc_edge). Inoltre è possibile ottenere un arco utilizzando una porzione di un cerchio:

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

Gli archi sono bordi validi, come le linee, quindi possono essere usati anche nei contorni.

Creare un poligono

Un poligono è semplicemente un contorno composto da diversi bordi diritti. La funzione makePolygon prende una lista di punti e crea un contorno attraverso questi punti:

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

Creare una curva di Bézier

Le curve di Bézier sono utilizzate per modellare delle curve morbide utilizzando una serie di Poles (punti) e weight (pesi) opzionali. La funzione sottostante crea una Part.BezierCurve da una serie di punti FreeCAD.Vector. (Notare che gli indici di pole e di weight partono da 1, non da 0.)

def makeBCurveEdge(Points):
   geomCurve = Part.BezierCurve()
   geomCurve.setPoles(Points)
   edge = Part.Edge(geomCurve)
   return(edge)

Creare un piano

Un Piano è semplicemente una superficie piana rettangolare. Il metodo utilizzato per crearlo è questo: makePlane(lunghezza, larghezza, [start_pnt, dir_normal]). Per impostazione predefinita start_pnt=Vector (0,0,0) e dir_normal=Vector(0,0,1). Utilizzando dir_normal=Vector(0,0,1) creeremo il piano orientato come l'asse z positivo, mentre con dir_normal=Vector(1,0,0) creeremo il piano orientato come l'asse x positivo:

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 è il parallelepipedo che racchiude il piano e la cui diagonale parte da (3,0,0) e termina in (5,0,2). Qui lo spessore di BoundBox sull'asse y è zero, poiché la nostra forma è totalmente piatta.

Nota: makePlane accetta solo Base.Vector() per start_pnt e dir_normal e non tuple.

Creare una ellisse

Per creare un'ellisse ci sono diversi modi:

Part.Ellipse()

Crea un'ellisse con raggio maggiore 2 e raggio minore 1 con centro in (0,0,0).

Part.Ellipse(Ellipse)

Crea una copia dell'ellisse data.

Part.Ellipse(S1,S2,Center)

Crea un'ellisse centrato sul punto Center, in cui il piano dell'ellisse è definito da Center, S1 e S2, il suo asse maggiore è definito da Center e S1, il suo raggio maggiore è la distanza tra Center e S1, e il suo raggio minore è la distanza tra S2 e l'asse maggiore.

Part.Ellipse(Center,MajorRadius,MinorRadius)

Crea un'ellisse con il raggio maggiore e il raggio minore MajorRadius e MinorRadius, e situata nel piano definito da Center e la normale (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())

Nel codice precedente abbiamo passato S1, S2 e il centro. Analogamente a Arco, Ellisse crea un oggetto ellisse ma non un bordo, quindi, per visualizzarlo è necessario di convertirlo in bordo utilizzando toShape().

Nota: Arc accetta solo Base.Vector() per i punti, ma non le tuple.

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

per il costruttore Ellisse precedente abbiamo passato il centro, MajorRadius e MinorRadius.

Creare un toro

Utilizzando il metodo makeTorus(radius1,radius2,[pnt,dir,angle1,angle2,angle]). Per impostazione predefinita PNT=Vector(0,0,0), dir=Vector(0,0,1), angle1=0, angle2=360 e angolo=360. Si consideri un toro, come un cerchio piccolo che si muove lungo un cerchio grande. Radius1 è il raggio del cerchio grande, radius2 è il raggio del cerchio piccolo, pnt è il centro del toro e dir è la direzione normale. angle1 e angle2 sono angoli in radianti per il cerchio piccolo cerchio, l'ultimo parametro angolo serve per realizzare una porzione del toro:

torus = Part.makeTorus(10, 2)

Il codice precedente creerà un toro con diametro 20 (raggio 10) e spessore di 4 (raggio del cerchio piccolo 2)

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

Il codice sopra creerà una fetta del toro.

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

Il codice precedente creerà un semi toro; solo l'ultimo parametro viene modificato vale a dire l'angolo e gli angoli rimanenti sono predefiniti. Impostare il valore dell'angolo a 180 creerà il toro da 0 a 180, cioè, un mezzo toro.

Creare un cubo o parallelepipedo

Utilizzando makeBox(lunghezza, larghezza, altezza,[pnt,dir]). Per impostazione predefinita pnt=Vector(0,0,0) e dir=Vector(0,0,1).

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

Creare una sfera

Utilizzando makeSphere(radius,[pnt, dir, angle1,angle2,angle3]). Per impostazione predefinita pnt=Vector(0,0,0), dir=Vector(0,0,1), angle1=-90, angle2=90 e angle3=360. angle1 e angle2 sono il minimo e il massimo in verticale della sfera, angle3 è il diametro della sfera stessa.

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

Creare un cilindro

Utilizzando makeCylinder(radius,height,[pnt,dir,angle]). Per impostazione predefinita pnt=Vector(0,0,0),dir=Vector(0,0,1) e angle=360.

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

Creare un cono

Utilizzando makeCone(radius1,radius2,height,[pnt,dir,angle]). Per impostazione predefinita pnt=Vector(0,0,0), dir=Vector(0,0,1) e 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)

Modificare delle forme

Ci sono diversi modi per modificare le forme. Alcuni sono semplici operazioni di trasformazione come lo spostamento o la rotazione di forme, altri sono più complessi, come ad esempio unire e sottrarre una forma da un'altra.

Operazioni di trasformazione

Traslare una forma

Traslare è l'atto di spostare una forma da un luogo all'altro. Qualsiasi forma (bordo, faccia, cubo, ecc ..) può essere traslata in questo modo:

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

Questo sposterà la forma "myShape" di 2 unità nella direzione dell'asse x.

Ruotare una forma

Per ruotare una forma, è necessario specificare il centro di rotazione, l'asse e l'angolo di rotazione:

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

Il codice precedente ruota la forma di 180 gradi attorno all'asse z.

Trasformazioni generiche, con matrici

Una matrice è un modo molto conveniente per memorizzare le trasformazioni nel mondo 3D. In una matrice singola, è possibile impostare valori di traslazione, rotazione e scala da applicare ad un oggetto. Ad esempio:

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

Nota. Le matrici di FreeCAD lavorano in radianti. Inoltre, quasi tutte le operazioni di matrici che accettano un vettore possono anche accettare tre numeri, quindi le seguenti due linee fanno la stessa cosa:

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

Quando la matrice è impostata, possiamo applicarla alla nostra forma. FreeCAD fornisce due metodi per farlo: transformShape() e transformGeometry(). La differenza è che con il primo, si è sicuri che non si verifichino deformazioni (vedi "scalare una forma" più avanti). Quindi possiamo applicare la nostra trasformazione in questo modo:

myShape.transformShape(myMat)

oppure

myShape.transformGeometry(myMat)

Scalare una forma

Scalare (ridimensionare) una forma è una delle operazioni più pericolose perché, a differenza della traslazione o della rotazione, il ridimensionamento non uniforme (con valori diversi per gli assi x, y, z) può modificare la struttura della forma. Ad esempio, la scalatura di un cerchio con un valore in orizzontale diverso da quello in verticale lo trasformerà in un ellisse, forma che matematicamente si comporta in modo molto diverso. Per il ridimensionamento, non possiamo usare transformShape, ma dobbiamo usare transformGeometry():

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

Operazioni Booleane

Sottrazione

Nel gergo OCC/FreeCAD, la differenza (sottrazione) di una forma da un altra si chiama "cut" taglia e si esegue così:

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)

Intersezione

Allo stesso modo, l'intersezione tra le due forme è chiamato "common" intersezione e viene eseguita in questo 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)

Unione

Unione è chiamata "fuse" fusione e funziona allo stesso 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)

Sezione

Una sezione è l'intersezione tra una forma solida e una forma piana. Restituisce una curva di intersezione, un composto con i bordi:

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>]

Estrusione

Estrusione è l'atto di "spingere" una forma piatta in una certa direzione per produrre un corpo solido. Ad esempio, pensate di "spingere" un cerchio e di produrre un tubo:

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

Se il cerchio è vuoto (sola circonferenza), si ottiene un tubo (cavo). Se il cerchio è in realtà un disco, con una faccia piena, si ottiene un cilindro solido:

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

Esplorare le forme

Si può facilmente esplorare la struttura dei dati topologici:

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

Digitando le righe di cui sopra nell'interprete Python, si otterrà una buona descrizione della struttura degli oggetti Parte. Qui, il nostro comando makeBox() crea una forma solida. Questo solido, come tutti i solidi Parte, contiene delle facce. Le facce contengono sempre delle linee (polilinee), che sono liste di bordi che delimitano la faccia. Ciascuna faccia ha almeno un contorno chiuso (ne può avere più di uno se la faccia presenta dei fori). Nel contorno, possiamo guardare a ciascun bordo separatamente, e all'interno di ogni bordo, possiamo vedere i vertici. Ovviamente, i bordi diritti hanno solo due vertici.

Analizzare i bordi

Nel caso in cui il bordo è una curva arbitraria, è più probabile che si voglia fare una discretizzazione. In FreeCAD i bordi sono parametrizzati dalle loro lunghezze. Ciò significa che si può percorrere un bordo/curva con la sua lunghezza:

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

Ora è possibile accedere a un sacco di proprietà del bordo utilizzando la lunghezza come una posizione. Ciò significa che se il bordo è lungo 100 mm la posizione iniziale è 0 e la posizione finale è 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)

Utilizzare la selezione

Qui ora vediamo come possiamo usare la selezione che l'utente ha nel visualizzatore. Prima di tutto creiamo una scatola e la mostriamo nel visualizzatore:

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

Selezionate ora alcune facce o bordi. Con questo script è possibile iterare sopra tutti gli oggetti selezionati e i relativi elementi secondari:

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

Selezionate alcuni bordi e questo script calcolerà la lunghezza:

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

Esempio completo: La bottiglia OCC

Un esempio tipico si trova nella pagina OpenCasCade Technology Tutorial che spiega come costruire una bottiglia. Questo è un buon esercizio anche per FreeCAD. In effetti, se si segue il nostro esempio qui sotto e la pagina di OCC contemporaneamente, si capisce bene come sono implementate le strutture di OCC in FreeCAD. Lo script completo è anche incluso nell'installazione di FreeCAD (all'interno della cartella Mod/Part) e può essere chiamato dall'interprete python digitando:

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

Lo script completo

Questo è lo script 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.LineSegment(aPnt1,aPnt2)
   aSegment2=Part.LineSegment(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.makeFillet(myThickness/12.0,myBody.Edges)
   
   return myBody

el = makeBottle()
Part.show(el)

Spiegazione dettagliata

import Part, FreeCAD, math
from FreeCAD import Base

Avremo bisogno, naturalmente, del modulo Parte, ma anche del modulo FreeCAD.Base, che contiene le strutture base di FreeCAD come vettori e matrici.

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)

Qui definiamo la nostra funzione makeBottle. Questa funzione può essere chiamata senza argomenti, come abbiamo fatto in precedenza, nel qual caso si utilizzano i valori di default per la larghezza, l'altezza e lo spessore. Poi, si definisce un paio di punti che verranno utilizzati per costruire il nostro profilo base.

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

Qui definiamo la geometria effettiva: un arco, creato da tre punti, e due segmenti di linea, creati da due punti.

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

Ricordate la differenza tra geometria e forme? Qui costruiremo forme partendo dalla nostra geometria di costruzione. Prima costruiremo tre bordi (i bordi possono essere dritti o curvi), poi costruiremo un contorno con quei tre bordi.

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

Prima abbiamo costruito solo metà profilo. È più facile che costruire tutto l'intero profilo nello stesso modo, successivamente possiamo semplicemente rispecchiare quello che abbiamo costruito, e poi unire le due parti. Per prima cosa è necessario creare una matrice. Una matrice è un modo molto comune per applicare trasformazioni agli oggetti nel mondo 3D, in quanto essa può contenere in un'unica struttura tutte le trasformazioni di base che gli oggetti 3D possono subire (spostamento, rotazione e scalatura). Dopo aver creato la matrice, la specchiamo e creiamo una copia del nostro contorno applicando ad esso quella matrice di trasformazione. Ora abbiamo due contorni, e con essi possiamo produrre un terzo profilo, dal momento che i contorni sono in realtà liste di bordi.

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

Ora che abbiamo un contorno chiuso, esso può essere trasformato in una faccia. Una volta che abbiamo una faccia, possiamo estruderla. In questo modo, abbiamo effettivamente creato un solido. Poi si applica un piccolo arrotondamento al nostro oggetto, perché vogliamo ottenere una forma graziosa, non è vero?

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)

A questo punto, il corpo della nostra bottiglia è creato, ma abbiamo ancora bisogno di creare un collo. Così facciamo un nuovo solido, con un cilindro.

myBody = myBody.fuse(myNeck)

L'operazione di fusione, che in altre applicazioni a volte è chiamata unione, è molto potente. Si prenderà cura di incollare ciò che deve essere incollato e di rimuovere le parti che devono essere rimosse.

return myBody

Poi, otteniamo il nostro solido Parte come risultato della nostra funzione.

el = makeBottle()
Part.show(el)

Infine, chiamiamo la funzione per creare effettivamente la parte, e quindi renderla visibile.

Cubo forato

Ecco un esempio completo della costruzione di una scatola perforata.

La costruzione è fatta lato per lato e quando il cubo è finito, viene scavato un foro con cilindro che l'attraversa.

import Draft, Part, FreeCAD, math, PartGui, FreeCADGui, PyQt4
from math import sqrt, pi, sin, cos, asin
from FreeCAD import Base

size = 10
poly = Part.makePolygon( [ (0,0,0), (size, 0, 0), (size, 0, size), (0, 0, size), (0, 0, 0)])

face1 = Part.Face(poly)
face2 = Part.Face(poly)
face3 = Part.Face(poly)
face4 = Part.Face(poly)
face5 = Part.Face(poly)
face6 = Part.Face(poly)
     
myMat = FreeCAD.Matrix()
myMat.rotateZ(math.pi/2)
face2.transformShape(myMat)
face2.translate(FreeCAD.Vector(size, 0, 0))

myMat.rotateZ(math.pi/2)
face3.transformShape(myMat)
face3.translate(FreeCAD.Vector(size, size, 0))

myMat.rotateZ(math.pi/2)
face4.transformShape(myMat)
face4.translate(FreeCAD.Vector(0, size, 0))

myMat = FreeCAD.Matrix()
myMat.rotateX(-math.pi/2)
face5.transformShape(myMat)

face6.transformShape(myMat)               
face6.translate(FreeCAD.Vector(0,0,size))

myShell = Part.makeShell([face1,face2,face3,face4,face5,face6])   

mySolid = Part.makeSolid(myShell)
mySolidRev = mySolid.copy()
mySolidRev.reverse()

myCyl = Part.makeCylinder(2,20)
myCyl.translate(FreeCAD.Vector(size/2, size/2, 0))

cut_part = mySolidRev.cut(myCyl)

Part.show(cut_part)

Caricare e salvare

Nel modulo Parte ci sono diversi modi per salvare il proprio lavoro. Naturalmente, è possibile salvare il documento in formato FreeCAD, ma è anche possibile salvare gli oggetti Parte direttamente nei comuni formati CAD, come ad esempio BREP, IGS, STEP e STL.

Salvare una forma in un file è facile. Per tutti gli oggetti di forma sono disponibili i metodi exportBrep(), exportIges(), exportStl() e exportStep(). Così, facendo:

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

salviamo il nostro box in un file STEP. Per caricare un file BREP, IGES o STEP basta fare:

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

Per convertire un file .stp in un file .igs fare:

import Part
 s = Part.Shape()
 s.read("file.stp")       # incoming file igs, stp, stl, brep
 s.exportIges("file.igs") # outbound file igs

Notare che l'importazione o l'apertura di file BREP, IGES o STEP può essere effettuata anche direttamente dal menu File → Apri o File → Importa, mentre l'esportazione si esegue con File → Esporta.

Arrow-left.svg Script per Mesh Pagina precedente:
Pagina successiva: Da Mesh a Parte e viceversa Arrow-right.svg



Arrow-left.svg Script di dati topologici Pagina precedente:
Pagina successiva: Grafo della scena Arrow-right.svg

Convertire oggetti Parte in Mesh

La conversione di oggetti di alto livello come le forme di Parte in oggetti semplici come gli oggetti Mesh è una operazione piuttosto semplice, nella quale tutte le facce di un oggetto Parte vengono triangolate (suddivise in maglie di una rete). Il risultato di tale triangolazione (tassellatura) viene poi utilizzato per costruire un oggetto mesh: (supponiamo che il nostro documento contenga un oggetto Parte)

#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)

A volte la triangolazione di alcune facce offerta da OpenCascade è abbastanza brutta. Se la faccia ha una forma rettangolare e non contiene buchi o altre curve di taglio è possibile creare una tassellatura da soli:

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

Convertire oggetti Mesh in Parte

La conversione di oggetti Mesh in oggetti Parte è un'operazione estremamente importante nel lavoro CAD perché molto spesso i dati 3D si ricevono da altri in formato mesh o sono generati da altre applicazioni. I mesh sono molto pratici per rappresentare le geometrie di forma libera e grandi scene visive in quanto sono molto leggeri, ma per lavori CAD si preferiscono generalmente oggetti di livello superiore, che contengono molte più informazioni, come il concetto di solido, o facce composte da curve invece che da triangoli.

Convertire gli oggetti mesh in oggetti di livello superiore, come sono gli oggetti gestiti dal Modulo Parte di FreeCAD non è un'operazione facile. L'oggetto Mesh può contenere migliaia di triangoli (per esempio quando è generato da uno scanner 3D), e manipolare solidi costituiti dallo stesso numero di facce sarebbe estremamente pesante. Quindi, in genere, si desidera ottimizzare l'oggetto durante la conversione.

FreeCAD attualmente offre due metodi per convertire Mesh in oggetti Parte. Il primo metodo è una semplice conversione, diretta, senza alcuna ottimizzazione:

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)

Il secondo metodo offre la possibilità di considerare complanari le sfaccettature delle maglie quando l'angolo tra di loro è inferiore a un certo valore. Questo permette di costruire delle forme molto più semplici: (supponiamo che il nostro documento contenga un oggetto Mesh)

# 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 list
        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)
Arrow-left.svg Script di dati topologici Pagina precedente:
Pagina successiva: Grafo della scena Arrow-right.svg


Arrow-left.svg Da Mesh a Parte Pagina precedente:
Pagina successiva: Pivy Arrow-right.svg

Le geometrie che appaiono nelle viste 3D di FreeCAD sono visualizzate (renderizzate) dalla libreria Coin3D. Coin3D è un'implementazione delle funzionalità standard di OpenInventor. Anche il software openCascade fornisce queste funzionalità, ma, fin dagli inizi dello sviluppo di FreeCAD, è stato deciso di non utilizzare il visualizzatore di OpenCascade e di sostituirlo con il software Coin3D in quanto più performante. Un buon modo per conoscere questa libreria è quello di consultare il manuale Open Inventor Mentor.

OpenInventor è in realtà un linguaggio di descrizione della scena 3D. La scena descritta in OpenInventor viene renderizzata (visualizzata) sul vostro schermo con OpenGL. Coin3D si occupa di questo processo, quindi non è necessario che il programmatore tratti complesse chiamate a OpenGL, ma deve solo fornire un codice OpenInventor valido. Il principale vantaggio è che OpenInventor è uno standard molto conosciuto e ben documentato.

Sostanzialmente, uno dei lavori più importanti che FreeCAD esegue per noi consiste nel tradurre le informazioni sulla geometria OpenCascade in linguaggio OpenInventor.

OpenInventor descrive una scena 3D in forma di grafo di scena (Scenegraph), come quello seguente:

Scenegraph.gif immagine da Inventor mentor

Un grafo di scena di OpenInventor è una struttura di tipo "grafico ad albero" e descrive tutto ciò che fa parte di una scena 3D, come ad esempio la geometria, i colori, i materiali, le luci, ecc, e organizza tutti i dati in una struttura gerarchica, pratica e chiara. Tutto può essere raggruppato in sotto-strutture (nodi-figlio), il che consente di organizzare i contenuti della scena più o meno nel modo desiderato. Ecco un esempio di un file di 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 {
       }
    }
}

Come si vede, la struttura è molto semplice. Si utilizzano i nodi (separator) per organizzare i dati in blocchi, un po' come si fa per organizzare i file in cartelle e sottocartelle. Ogni dichiarazione riguarda ciò che viene in seguito, per esempio, i primi due elementi del nostro nodo radice (root separator) sono una rotazione e una traslazione e agiscono entrambi sull'elemento successivo, che è un nodo (separator). In tale nodo sono definiti un materiale e una ulteriore trasformazione. Pertanto, il nostro cilindro sarà influenzato da entrambe le trasformazioni, da quella che è stata applicata direttamente ad esso e da quella che è stata applicata al suo nodo (separator) genitore.

Per organizzare la una scena, sono disponibili molti altri tipi di elementi, come gruppi, commutatori o annotazioni. Per gli oggetti si possono definire dei materiali molto complessi, con colori, texture, modalità di ombreggiatura e trasparenza. Si possono anche definire luci, punti di vista (camera) e perfino il movimento. È anche possibile incorporare parti di script nei file di OpenInventor, per definire comportamenti più complessi.

Se siete interessati a saperne di più su OpenInventor, consultate direttamente il suo manuale più famoso: il libro Inventor mentor.

Normalmente, in FreeCAD, non è necessario interagire direttamente con il grafo della scena di OpenInventor. Ogni oggetto in un documento di FreeCAD, sia che si tratti di un Mesh, di una forma Parte o di qualsiasi altra cosa, viene automaticamente convertito in codice OpenInventor e inserito nel grafo della scena principale che appare in una vista 3D. Questo grafo di scena viene costantemente aggiornato tutte le volte che si apportano delle modifiche, oppure si aggiungono o si rimuovono degli oggetti nel documento. In realtà, ogni oggetto (nell'ambito App) ha un fornitore di vista (un corrispondente oggetto nell'ambito Gui), responsabile del rilascio del codice OpenInventor.

Potere accedere al direttamente al grafico di scena presenta comunque molti vantaggi. Ad esempio, si può modificare temporaneamente la visualizzazione di un oggetto, oppure si possono aggiungere alla scena oggetti che nel documento di FreeCAD non hanno esistenza reale, come la geometria di costruzione, i riferimenti, i suggerimenti grafici oppure strumenti quali i manipolatori oppure informazioni sullo schermo.

FreeCAD dispone di diversi strumenti per visualizzare o modificare il codice OpenInventor. Ad esempio, il seguente codice Python mostra la rappresentazione OpenInventor di un oggetto selezionato:

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

Inoltre, c'è anche un modulo Python che consente l'accesso completo a tutto quello che è gestito da Coin3D, come il grafico di scena di FreeCAD. Continuate quindi la lettura in Pivy.

Arrow-left.svg Da Mesh a Parte Pagina precedente:
Pagina successiva: Pivy Arrow-right.svg


Arrow-left.svg Grafo di scena Pagina precedente:
Pagina successiva: PySide Arrow-right.svg

Pivy è una libreria che collega Python con Coin3d, ed è la libreria di renderizzazione-3D utilizzata in FreeCAD. Quando viene importata in un interprete Python in esecuzione, permette di dialogare direttamente con qualsiasi grafo di scena (scenegraph) di Coin3d in esecuzione, come ad esempio le viste 3D di FreeCAD, o addirittura di creare nuovi grafi di scena. Pivy è incluso nell'installazione standard di FreeCAD.

La libreria Coin è divisa in vari moduli, Coin stessa, per manipolare grafi di scene e associarli a diversi sistemi GUI, come a Windows oppure, come nel nostro caso, a Qt. Tali moduli sono disponibili anche per Pivy, se sono presenti nel sistema. Il modulo Coin è sempre presente, ed è quello che useremo in tutti gli esempi, e non sarà necessario preoccuparsi di associare la nostra visualizzazione 3D ad alcuna interfaccia, perchè questo viene già fatto da FreeCAD stesso. Tutto quello che dobbiamo fare è:

from pivy import coin

Accesso e modifica del Grafo della scena (Scenegraph)

Abbiamo già visto nella pagina Grafo della scena (Scenegraph) come è organizzata una tipica scena di Coin. Tutto ciò che appare in una vista 3D di FreeCAD è un Scenegraph di Coin, organizzato allo stesso modo. Abbiamo un nodo radice (principale), e tutti gli oggetti sullo schermo sono suoi figli.

FreeCAD dispone di un modo semplice per accedere al nodo radice (root) di una scena grafica in vista 3D:

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

Ciò restituisce il nodo principale (root):

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

Siamo in grado di ispezionare i figli immediati della nostra scena:

for node in sg.getChildren():
    print node

Alcuni di questi nodi, ad esempio SoSeparators o SoGroups, possono avere dei propri figli. L'elenco completo degli oggetti Coin disponibili si può trovare nella documentazione ufficiale di Coin.

Ora proviamo ad aggiungere qualcosa al nostro Scenegraph. Aggiungiamo un bel cubo rosso:

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

e questo è il nostro (bel) cubo rosso. Ora, proviamo questo:

col.rgb=(1,1,0)

Visto? Tutto è sempre accessibile e modificabile al volo. Non c'è bisogno di ricalcolare o ridisegnare nulla, Coin si prende cura di tutto. È possibile aggiungere elementi al grafo di scena, modificare le proprietà, nascondere delle cose, mostrare oggetti temporanei, qualsiasi cosa. Naturalmente, questo riguarda solo la visualizzazione nella vista 3D. Questa visualizzazione viene determinata da FreeCAD all'apertura del file attivo e quando un oggetto ha bisogno di essere ricalcolato. Quindi, se si modifica l'aspetto di un oggetto di FreeCAD esistente, tali modifiche andranno perse se l'oggetto viene ricalcolato o quando si riapre il file.

Per lavorare con i grafi di scena nei nostri script è fondamentale saper accedere a specifiche proprietà dei nodi aggiunti quando questo è necessario. Per esempio, se avessimo voluto spostare il nostro cubo, avremmo aggiunto un nodo SoTranslation al nostro nodo personalizzato, e lo script apparirebbe così:

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)

Ricordate che, in un Scenegraph di OpenInventor, l'ordine è importante. Un nodo riguarda ciò che viene dopo, quindi permette di definire qualcosa come: colore rosso, cubo, colore giallo, sfera, e di ottenere un cubo rosso e una sfera gialla. Se aggiungiamo ora la traslazione al nostro nodo personalizzato esistente, essa viene dopo il cubo, e non lo condiziona. Se lo avessimo inserito durante la creazione, come qui sopra, ora si potrebbe fare:

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

E il nostro cubo si sposterebbe di 2 unità a destra.

Infine, la rimozione di qualcosa si fà con:

sg.removeChild(myCustomNode)

Utilizzo dei meccanismi di richiamo (callback)

Un callback mechanism (meccanismo di richiamo) è un sistema che permette a una libreria che si sta utilizzando, come la nostra libreria Coin, di richiamare, cioè, di chiamare una determinata funzione dell'oggetto Python attualmente in esecuzione. Ciò è estremamente utile, perché in questo modo Coin può avvisarci se nella scena si verifica qualche evento specifico. Coin può controllare cose molto diverse, come la posizione del mouse, i clic di un pulsante del mouse, i tasti della tastiera che vengono premuti e tante altre cose.

FreeCAD fornisce un modo semplice per utilizzare tali callback:

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()

Il richiamo deve essere iniziato da un oggetto, perché questo oggetto deve essere ancora in esecuzione quando il callback si verifica. Vedere anche la lista completa degli eventi possibili e dei loro parametri, o la documentazione ufficiale di Coin.

Documentazione

Purtroppo, Pivy non ha ancora una propria documentazione adeguata, ma dato che è una traduzione esatta di Coin, si può tranquillamente utilizzare la documentazione di Coin come riferimento, e utilizzare lo stile Python al posto dello stile C++; ad esempio SoFile::getClassTypeId() in Pivy si scrive SoFile.getClassId().

Arrow-left.svg Grafo di scena Pagina precedente:
Pagina successiva: PySide Arrow-right.svg


Arrow-left.svg Pivy Pagina precedente:
Pagina successiva: Script per oggetti Arrow-right.svg

PySide

PySide è il legame tra Python e la multi-piattaforma GUI degli strumenti di Qt. FreeCAD usa PySide all'interno di Python per tutti gli effetti GUI (Interfaccia grafica per l'utente). PySide è una alternativa al pacchetto PyQt che è stato utilizzato in precedenza da FreeCAD per la sua GUI. PySide ha una licenza più permissiva. Per maggiori informazioni sulla differenza vedere Differences Between PySide and PyQt.

Spesso gli utenti di FreeCAD accedono a tutto tramite l'interfaccia integrata. Per gli utenti che desiderano personalizzare le loro operazioni esiste l'interfaccia Python, che è documentata nel Tutorial degli script Python. L'interfaccia Python di FreeCAD è molto flessibile e potente. Questa pagina documenta l'interazione di Python con FreeCAD tramite PySide.

Python offre la dichiarazione 'print', data dal codice:

print 'Hello World'

Con l'istruzione print di Python si ha solo un limitato controllo dell'aspetto e del comportamento. PySide fornisce il controllo mancante e gestisce anche gli ambienti dove le funzionalità incorporate in Python non sono sufficienti, come ad esempio i file dell'ambiente macro di FreeCAD.

Le funzionalità di PySide vanno da:

PySideScreenSnapshot1.jpg

a:

PySideScreenSnapshot2.jpg

Esse suddividono l'argomento in 3 parti, e si differenziano per livello di esposizione per PySide, Python e le parti incorporate in FreeCAD. La prima pagina contiene una panoramica e le basi della materia, fornisce una descrizione di PySide e di come è organizzato, mentre la seconda e la terza pagina contengono soprattutto degli esempi di codice di diversi livelli.

Con le pagine allegate si intende fornire del semplice codice Python per eseguire PySide, in modo che l'utente possa facilmente copiarlo, incollarlo nel proprio lavoro, adattarlo se necessario, e risolvere i suoi problemi con FreeCAD. Sperando che non abbia bisogno di andare alla ricerca di risposte alle domande su PySide attraverso internet. Allo stesso tempo, queste pagine non vogliono sostituirsi ai vari tutorial completi e ai siti di riferimento a PySide presenti nel web.

Arrow-left.svg Pivy Pagina precedente:
Pagina successiva: Script per oggetti Arrow-right.svg


Arrow-left.svg PySide Pagina precedente:
Pagina successiva: Incorporare FreeCAD Arrow-right.svg

Oltre ai tipi di oggetti standard, come le Annotazioni, gli oggetti Mesh e gli oggetti Parte, FreeCAD offre anche la straordinaria possibilità di costruire al 100% oggetti in script di Python, chiamati Python Feature (Caratteristiche Python). Questi oggetti si comportano esattamente come un qualsiasi altro oggetto di FreeCAD, e sono salvati e ripristinati automaticamente con salva/apri il file.

Deve essere conosciuta una loro particolarità: questi oggetti vengono salvati in un file FcStd di FreeCAD con il modulo json di Python. Tale modulo converte un oggetto Python in una stringa, permettendo di aggiungerlo al file salvato. Quando l'oggetto viene caricato, il modulo json utilizza questa stringa per ricreare l'oggetto originale, fornendo l'accesso al codice sorgente da cui ha creato l'oggetto. Questo significa che se si salva un oggetto personalizzato e lo si apre su una macchina in cui non è presente il codice Python che ha generato l'oggetto, l'oggetto non può essere ricreato. Quando si forniscono ad altri utenti questi oggetti, è necessario fornire anche gli script di Python che li hanno creati.

Le Python Features seguono le stesse regole di tutte le altre funzionalità di FreeCAD: sono divise in una parte App e una parte GUI. La parte App, cioè il Document Object (oggetto del documento), definisce la geometria dell'oggetto, mentre la sua parte grafica, cioè il View Provider Object (fornitore della vista dell'oggetto), definisce come l'oggetto viene disegnato sullo schermo. Il View Provider Object, come qualsiasi altro elemento di FreeCAD, è disponibile solo quando si esegue FreeCAD nella sua GUI (interfaccia grafica). Per costruire il proprio oggetto, sono disponibili diversi metodi e proprietà. La Proprietà deve essere una qualsiasi dei tipi di proprietà predefinite che FreeCAD mette a disposizione. Le proprietà disponibili sono quelle che appaiono nella finestra di visualizzazione delle proprietà per consentire all'utente di modificarle. Con questa procedura, gli oggetti FeaturePython sono realmente e totalmente parametrici. E' possibile definire separatamente le proprietà per l'oggetto e per la sua ViewObject (rappresentazione).

Nota. In versioni precedenti abbiamo usato il modulo cPickle di Python. Questo modulo, però, esegue un codice arbitrario e provoca quindi un problema di sicurezza. Per questo motivo ora utilizziamo il modulo json di Python.

Esempio base

L'esempio seguente si trova nel file src/Mod/TemplatePyMod/FeaturePython.py, con molti altri esempi:

'''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(float(l),float(w),float(h))
        pass
 
    def getDisplayModes(self,obj):
        '''Return a list of display modes.'''
        modes=[]
        modes.append("Shaded")
        modes.append("Wireframe")
        return modes
 
    def getDefaultDisplayMode(self):
        '''Return the name of the default display mode. It must be defined in getDisplayModes.'''
        return "Shaded"
 
    def setDisplayMode(self,mode):
        '''Map the display mode defined in attach with those defined in getDisplayModes.\
                Since they have the same names nothing needs to be done. This method is optional'''
        return mode
 
    def onChanged(self, vp, prop):
        '''Here we can do something when a single property got changed'''
        FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
        if prop == "Color":
            c = vp.getPropertyByName("Color")
            self.color.rgb.setValue(c[0],c[1],c[2])
 
    def getIcon(self):
        '''Return the icon in XPM format which will appear in the tree view. This method is\
                optional and if not defined a default icon is shown.'''
        return """
            /* XPM */
            static const char * ViewProviderBox_xpm[] = {
            "16 16 6 1",
            "   c None",
            ".  c #141010",
            "+  c #615BD2",
            "@  c #C39D55",
            "#  c #000000",
            "$  c #57C355",
            "        ........",
            "   ......++..+..",
            "   .@@@@.++..++.",
            "   .@@@@.++..++.",
            "   .@@  .++++++.",
            "  ..@@  .++..++.",
            "###@@@@ .++..++.",
            "##$.@@$#.++++++.",
            "#$#$.$$$........",
            "#$$#######      ",
            "#$$#$$$$$#      ",
            "#$$#$$$$$#      ",
            "#$$#$$$$$#      ",
            " #$#$$$$$#      ",
            "  ##$$$$$#      ",
            "   #######      "};
            """
 
    def __getstate__(self):
        '''When saving the document this object gets stored using Python's json module.\
                Since we have some un-serializable parts here -- the Coin stuff -- we must define this method\
                to return a tuple of all serializable objects or None.'''
        return None
 
    def __setstate__(self,state):
        '''When restoring the serialized object from document we have the chance to set some internals here.\
                Since no data were serialized nothing needs to be done here.'''
        return None


def makeBox():
    FreeCAD.newDocument()
    a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box")
    Box(a)
    ViewProviderBox(a.ViewObject)

makeBox()

Proprietà disponibili

Le proprietà sono i veri e propri mattoni per la costruzione degli oggetti FeaturePython. Attraverso di esse, l'utente è in grado di interagire e modificare l'oggetto. Dopo aver creato un nuovo oggetto FeaturePython nel documento ( obj=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box") ), è possibile ottenere un elenco delle proprietà disponibili digitando:

obj.supportedProperties()

Si ottiene l'elenco delle proprietà disponibili:

App::PropertyBool
App::PropertyBoolList
App::PropertyFloat
App::PropertyFloatList
App::PropertyFloatConstraint
App::PropertyQuantity
App::PropertyQuantityConstraint
App::PropertyAngle
App::PropertyDistance
App::PropertyLength
App::PropertySpeed
App::PropertyAcceleration
App::PropertyForce
App::PropertyPressure
App::PropertyInteger
App::PropertyIntegerConstraint
App::PropertyPercent
App::PropertyEnumeration
App::PropertyIntegerList
App::PropertyIntegerSet
App::PropertyMap
App::PropertyString
App::PropertyUUID
App::PropertyFont
App::PropertyStringList
App::PropertyLink
App::PropertyLinkSub
App::PropertyLinkList
App::PropertyLinkSubList
App::PropertyMatrix
App::PropertyVector
App::PropertyVectorList
App::PropertyPlacement
App::PropertyPlacementLink
App::PropertyPlacementList
App::PropertyColor
App::PropertyColorList
App::PropertyMaterial
App::PropertyPath
App::PropertyFile
App::PropertyFileIncluded
App::PropertyPythonObject
Part::PropertyPartShape
Part::PropertyGeometryList
Part::PropertyShapeHistory
Part::PropertyFilletEdges
Sketcher::PropertyConstraintList

Quando si aggiungono delle proprietà agli oggetti personalizzati, stare attenti a questo:

  • Non utilizzare i caratteri "<" o ">" nelle descrizioni delle proprietà (questo spezza le parti xml nel file .fcstd)
  • Le proprietà sono memorizzate in ordine alfabetico nel file .fcstd. Se si dispone di una forma (Shape) nelle proprietà, qualsiasi proprietà il cui nome, in ordine alfabetico, viene dopo "Shape", verrà caricato DOPO la forma (Shape), e questo può causare strani comportamenti.

A complete list of property attributes can be seen in the PropertyStandard C++ header file. For instance, if you want to allow the user to enter only a limited range of values (e.g. using PropertyIntegerConstraint), in Python you will assign a tuple containing not only the property value, but also the lower and upper limit as well as the stepsize, as below:

prop = (value, lower, upper, stepsize)

Tipi di Proprietà

Di default, le proprietà possono essere aggiornate. È possibile creare delle proprietà di sola lettura, per esempio nel caso si vuole mostrare il risultato di un metodo. È anche possibile nascondere una proprietà. Il tipo di proprietà può essere impostata usando

obj.setEditorMode("MyPropertyName", mode)

dove mode è un indice che può essere impostato:

 0 -- default mode, lettura e scrittura
 1 -- solo lettura
 2 -- nascosto

Gli EditorModes non sono fissati nel file reload di FreeCAD. Questo può essere fatto dalla funzione __setstate__ . Vedere http://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=10#p108072. Usando setEditorMode le proprietà sono in sola lettura soltanto in PropertyEditor. Esse possono ancora essere modificate da un comando Python. Per renderle davvero in sola lettura le impostazioni devono essere passate direttamente all'interno della funzione addProperty. Per un esempio, vedere http://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=20#p109709.

Using the direct setting in the addProperty function, you also have more possibilities. In particular, an interesting one is mark a property as an output property. This way FreeCAD won't mark the feature as touched when changing it (so no need to recompute).

Example of output property (see also https://forum.freecadweb.org/viewtopic.php?t=24928):

obj.addProperty("App::PropertyString","MyCustomProperty","","",8)

The property types that can be set at last parameter of the addProperty function are:

 0 -- Prop_None, No special property type
 1 -- Prop_ReadOnly, Property is read-only in the editor
 2 -- Prop_Transient, Property won't be saved to file
 4 -- Prop_Hidden, Property won't appear in the editor
 8 -- Prop_Output, Modified property doesn't touch its parent container
 16 -- Prop_NoRecompute, Modified property doesn't touch its container for recompute


You can find these different property types defined in the source code C++ header for PropertyContainer

Altro esempio più complesso

In questo esempio si utilizza il Modulo Parte per creare un ottaedro, quindi si crea la sua rappresentazione Coin con Pivy.

Prima si crea l'oggetto del documento:

import FreeCAD, FreeCADGui, Part
import pivy
from pivy import coin

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

In seguito si crea il fornitore della vista dell'oggetto (view provider object), responsabile di mostrare l'oggetto nella scena 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

Infine, dopo che l'oggetto e il suo visualizzatore sono definiti, basta solo chiamarli (La classe Octahedron e il codice della classe viewprovider possono essere copiati direttamente nella console Python di FreeCAD)::

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

Rendere gli oggetti selezionabili

Se volete rendere il vostro oggetto selezionabile, o almeno una parte di esso, facendo clic su di esso nella finestra, è necessario includere la sua geometria Coin all'interno di un nodo SoFCSelection. Se l'oggetto ha una rappresentazione complessa, con widget, annotazioni, etc, si potrebbe voler includere solo una parte di esso in un SoFCSelection. Tutto quello che compone un SoFCSelection viene costantemente analizzato da FreeCAD per rilevare selezioni/preselezioni, quindi non ha senso sovraccaricarlo con delle scansioni non necessarie. Ecco ciò che si dovrebbe fare per includere un self.face nell'esempio precedente:

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)

Praticamente, si crea un nodo SoFCSelection, quindi si aggiungono ad esso i nodi della geometria, e poi lo si aggiunge al nodo principale, invece di aggiungere direttamente i nodi geometria.

Lavorare con le forme semplici

Se l'oggetto parametrico produce semplicemente una forma, non è necessario utilizzare un fornitore di vista dell'oggetto (view provider object). La forma viene visualizzata utilizzando la rappresentazione della forma standard di FreeCAD:

import FreeCAD as App
import FreeCADGui
import FreeCAD
import Part
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()

Lo stesso codice con l'uso di ViewProviderLine

import FreeCAD as App
import FreeCADGui
import FreeCAD
import Part

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(100,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)

class ViewProviderLine:
   def __init__(self, obj):
      ''' Set this object to the proxy object of the actual view provider '''
      obj.Proxy = self

   def getDefaultDisplayMode(self):
      ''' Return the name of the default display mode. It must be defined in getDisplayModes. '''
      return "Flat Lines"

a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","Line")
Line(a)
ViewProviderLine(a.ViewObject)
App.ActiveDocument.recompute()

Ulteriori informazioni

Ci sono alcune discussioni nel forum molto interessanti su script di oggetti:

- Python object attributes lost at load

- New FeaturePython is grey

- Eigenmode frequency always 0?

- how to implement python feature's setEdit properly?

Oltre agli esempi presentati qui dare un'occhiata al codice sorgente di FreeCAD src/Mod/TemplatePyMod/FeaturePython.py per ulteriori esempi.

Arrow-left.svg PySide Pagina precedente:
Pagina successiva: Incorporare FreeCAD Arrow-right.svg



Arrow-left.svg Srcipt di oggetti Pagina precedente:
Pagina successiva: Esempi di codice Arrow-right.svg

FreeCAD ha la sorprendente capacità di essere importabile come modulo Python in altri programmi o in una console autonoma di Python, insieme con tutti i suoi moduli e componenti. E' anche possibile importare la GUI di FreeCAD come modulo Python, anche se con alcune restrizioni. Però con alcune restrizioni.

Utilizzare FreeCAD senza GUI

Una prima, diretta, facile e utile applicazione che si può fare di questo è quella di importare i documenti di FreeCAD in un vostro programma. Nell'esempio che segue, si importa la geometria Parte di un documento di FreeCAD in Blender. Ecco lo script completo. Spero che sarete impressionati dalla sua semplicità:

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

La prima parte importante è fare in modo che Python trovi la nostra libreria di FreeCAD. Se la trova, tutti i moduli di FreeCAD, come il modulo Parte, che useremo anche, saranno automaticamente disponibili. Così noi prendiamo semplicemente la variabile sys.path, che è il posto dove Python cerca i moduli, e vi aggiungiamo il percorso di FreeCAD lib. Questa modifica è solo temporanea, e sarà persa quando chiuderemo il nostro interprete Python. Un altro modo potrebbe essere quello di creare un collegamento alla propria libreria di FreeCAD in uno dei percorsi di ricerca di Python. Io ho posto il percorso in una costante (FREECADPATH) in modo che per un altro utente dello script sarà più facile configurarlo per il proprio sistema.

Quando siamo sicuri che la libreria viene caricata (la sequenza try/except), possiamo lavorare con FreeCAD, allo stesso modo come faremmo all'interno dell'interprete Python di FreeCAD. Apriamo il documento FreeCAD che è passato a noi dalla funzione main(), e facciamo una lista dei suoi oggetti. Poi, siccome abbiamo deciso di preoccuparci solo della geometria del pezzo, controlliamo se la proprietà Type di ogni oggetto contiene "Parte", e dopo la tasselliamo.

Il tassellamento produce una lista di vertici e un elenco di facce definite dai vertici indicizzati. Questo è perfetto, poiché è esattamente lo stesso modo in cui Blender definisce i Mesh. Quindi, il nostro compito è ridicolmente semplice, basta aggiungere il contenuto di entrambi gli elenchi ai vertici e alle facce di una mesh di Blender. Quando tutto è fatto, basta ridisegnare lo schermo, e questo è tutto!

Ovviamente questo script è molto semplice (in realtà ne ho fatto uno più avanzato qui), è probabile che si voglia estenderlo, per esempio per importare anche oggetti mesh, o importare la geometria di una parte che non ha facce, o importare altri formati di file che FreeCAD è in grado di leggere. Si potrebbe anche voler esportare la geometria in un documento di FreeCAD, cosa che può essere fatto allo stesso modo. Si potrebbe anche voler costruire un dialogo per permettere all'utente di scegliere cosa importare, ecc.. La bellezza di tutto questo risiede proprio nel fatto che lasciate lavorare FreeCAD in ombra, mentre i suoi risultati sono presentati nel programma di vostra scelta.

Utilizzare FreeCAD con GUI

Dalla versione 4.2, Qt ha la capacità affascinante di incorporare i plug-in della GUI dipendenti da Qt in applicazioni ospite (host) non-Qt e condividere il ciclo di eventi dell'ospite.

In particolare, per FreeCAD questo significa che esso può essere importato (incorporato) all'interno di un'altra applicazione con tutta la sua interfaccia utente dentro un'altra applicazione ospite la quale ha, a questo punto, il pieno controllo di FreeCAD.

L'intero codice python per ottenere questo ha solo due linee:

import FreeCADGui 
FreeCADGui.showMainWindow()

Se l'applicazione ospite è basata su Qt, allora questa soluzione dovrebbe funzionare su tutte le piattaforme che supportano Qt. Tuttavia, l'ospite deve basarsi sulla stessa versione Qt di FreeCAD perché altrimenti si potrebbe incorrere in errori di esecuzione inaspettati.

Per le applicazioni non-Qt, tuttavia, ci sono alcune limitazioni di cui è necessario essere a conoscenza. Questa soluzione probabilmente non funziona con tutti gli altri toolkit. Per Windows funziona fintanto che l'applicazione ospite è basata direttamente su Win32 o su qualsiasi altro toolkit che utilizza internamente l'API Win32, come wxWidgets, MFC o WinForms. Al fine di farla funzionare sotto X11 l'applicazione ospite deve linkare la libreria "glib".

Notare che, questa soluzione, naturalmente, non funziona per nessuna applicazione da console perché non c'è nessun ciclo di eventi in esecuzione.

Avvertenze

Anche se è possibile importare FreeCAD con un interprete Python esterno, questo non è uno scenario di utilizzo comune e richiede una certa cura. In generale, è meglio usare il Python incluso con FreeCAD, eseguire FreeCAD da linea di comando, o come un sottoprocesso. Vedere Avvio e configurazione per maggiori informazioni sulle ultime due opzioni.

Dato che il modulo Python di FreeCAD viene compilato da C ++ (invece di essere un puro modulo Python), esso può essere importato solo da un interprete Python compatibile. Generalmente questo significa che l'interprete Python deve essere compilato con lo stesso compilatore C che è stato utilizzato per costruire FreeCAD. Le informazioni sul compilatore utilizzato per costruire un interprete Python (compreso quello costruito con FreeCAD) si possono trovare nel seguente modo:

>>> import sys
>>> sys.version
'2.7.13 (default, Dec 17 2016, 23:03:43) \n[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.42.1)]'


Arrow-left.svg Srcipt di oggetti Pagina precedente:
Pagina successiva: Esempi di codice Arrow-right.svg


Arrow-left.svg Incorporare FreeCAD Pagina precedente:
Pagina successiva: Funzione per disegnare linee Arrow-right.svg

Base ExampleCommandModel.png Tutorial

Argomento
Python
Livello di difficoltà
Base
Tempo di esecuzione
Autore
Versione di FreeCAD
File di esempio


Questa pagina contiene degli esempi di codice Python utilizzabili in FreeCAD, raccolti dalle esperienze degli utenti e dalle discussioni nel forum. Dopo averli letti, è possibile usarli per iniziare a creare degli script personali ...

Un tipico file InitGui.py

Ogni modulo deve contenere, oltre al file del modulo principale, un file InitGui.py che ha il compito di inserire il modulo nella finestra grafica principale (GUI).

Questo è un esempio semplice di un file InitGui.py:

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 tipico file del modulo

Il seguente è un esempio di un file del modulo principale. Esso contiene tutto ciò che il modulo deve seguire. È il file Scripts.py richiamato dall'esempio precedente. In esso è possibile inserire tutti i comandi personalizzati.

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())

Importare un nuovo tipo di file

In FreeCAD, è facile creare un importatore per un nuovo tipo di file. FreeCAD non considera che si importano dati in un documento aperto, ma piuttosto che si può semplicemente aprire direttamente il nuovo tipo di file. Quindi, quello che si deve fare è aggiungere la nuova estensione di file alla lista delle estensioni conosciute di FreeCAD, scrivere il codice che legge il file e creare gli oggetti di FreeCAD che si desidera:

Per aggiungere la nuova estensione di file all'elenco si deve aggiungere questa riga al file InitGui.py :

# 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")

Poi nel file 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()

L'esportazione di un proprio documento in un nuovo tipo di file funziona allo stesso modo, ma si utilizza:

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

Aggiungere una linea

Una linea ha semplicemente 2 punti.

import Part,PartGui 
doc=App.activeDocument() 
# add a line element to the document and set its points 
l=Part.LineSegment()
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()

Aggiungere un poligono

Un poligono è semplicemente un insieme di segmenti di linea collegati tra di loro (una polilinea in AutoCAD). Non è necessario che sia chiuso.

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()

Aggiungere e rimuovere un oggetto in un gruppo

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: È anche possibile annidare dei gruppi in altri gruppi e creare dei sottogruppi...

Aggiungere un Mesh

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

Aggiungere un arco o un cerchio

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()

Accedere alla rappresentazione di un oggetto e modificarla

A ogni oggetto di un documento di FreeCAD è associato un oggetto di rappresentazione della sua vista in cui sono memorizzati tutti i parametri che definiscono il modo in cui l'oggetto deve apparire, come il colore, la larghezza di linea, ecc ..

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

Controllare gli eventi del mouse nel visualizzatore 3D tramite Python

La struttura di Inventor permette di aggiungere uno o più nodi di richiamo (callback) al grafo di scena (Scenegraph) della vista. In FreeCAD è installato di default un nodo callback per la vista che permette di aggiungere funzioni C++ globali o statiche. In appropriate associazioni Python vengono forniti alcuni metodi per utilizzare questa tecnica all'interno del codice 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)

Ora, cliccate in qualche parte nella zona nella vista 3D e osservate i messaggi nella finestra di output. Per terminare l'osservazione basta chiamare:

v.removeEventCallback("SoMouseButtonEvent",c)

Sono supportati i seguenti tipi di eventi:

  • SoEvent -- Tutti i tipi di eventi
  • SoButtonEvent -- Tutti gli eventi del mouse e della tastiera
  • SoLocation2Event -- Eventi di movimento 2D (normalmente i movimenti del mouse)
  • SoMotion3Event -- Eventi di movimento 3D (normalmente di spaceball)
  • SoKeyboardEvent -- Eventi dei tasti alto e basso
  • SoMouseButtonEvent -- Eventi dei pulsanti del mouse verso il basso e verso l'alto
  • SoSpaceballButtonEvent -- Eventi di SpaceBall in basso e in alto

La funzione di Python che può essere registrata con addEventCallback() si aspetta una difinizione. Secondo l'evento controllato la definizione può contenere chiavi differenti.

Per tutti gli eventi esistono le seguenti chiavi:

  • Type -- Il nome del tipo di evento, ad esempio SoMouseEvent, SoLocation2Event, ...
  • Time -- L'ora corrente come stringa
  • Position -- Una tupla di due interi, dipendenti dalla posizione del mouse
  • ShiftDown -- un valore booleano, vero (true) se Shift è stato premuto altrimenti false
  • CtrlDown -- un valore booleano, true se è stato premuto Ctrl altrimenti false
  • AltDown -- un valore booleano, true se è stato premuto Alt altrimenti false

Per tutti gli eventi dei pulsanti, ad esempio eventi di tastiera, mouse o spaceball:

  • State -- Una stringa 'UP' se il pulsante è verso l'alto, 'DOWN' se è verso il basso o 'UNKNOWN' per tutti gli altri casi

Per gli eventi da tastiera:

  • Key -- Un carattere del tasto premuto

Per gli eventi del pulsante del mouse

  • Button -- Il pulsante premuto, potrebbe essere BUTTON1, ..., BUTTON5 o ANY

Per gli eventi di Spaceball:

  • Button -- Il pulsante premuto, potrebbe essere BUTTON1, ..., BUTTON7 o ANY

E infine eventi di movimento:

  • Translation -- Una tupla di tre numeri in virgola mobile
  • Rotation -- Un quaternione per la rotazione, cioè una tupla di quattro numeri in virgola mobile

Visualizzare i tasti premuti e gli eventi dei comandi

Questa macro visualizza nel report i tasti premuti e tutti gli eventi dei comandi

App.newDocument()
v=Gui.activeDocument().activeView()
class ViewObserver:
   def logPosition(self, info):
       try:
           down = (info["Key"])
           FreeCAD.Console.PrintMessage(str(down)+"\n") # here the character pressed
           FreeCAD.Console.PrintMessage(str(info)+"\n") # list all events command
           FreeCAD.Console.PrintMessage("_______________________________________"+"\n")
       except Exception:
           None
 
o = ViewObserver()
c = v.addEventCallback("SoEvent",o.logPosition)

#v.removeEventCallback("SoEvent",c) # remove ViewObserver

Manipolare il grafo della scena in Python

È anche possibile ottenere il Scenegraph (grafo della scena) in Python e modificarlo, con il modulo 'Pivy '- una associazione di Python per 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()

L'API in Python di Pivy viene creato utilizzando lo strumento SWIG. In FreeCAD si usano alcuni nodi auto-scritti che non è possibile creare direttamente in Python. Tuttavia, è possibile creare un nodo dal suo nome interno. Si può creare una istanza di tipo 'SoFCSelection' con:

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

Aggiungere e rimuovere oggetti nel grafo della scena

Questo è un modo per aggiungere dei nuovi nodi al Scenegraph. Accertarsi di aggiungere sempre un SoSeparator per contenere la geometria, le coordinate e le informazioni sui materiale di uno stesso oggetto. L'esempio seguente aggiunge una linea rossa da (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)

Per rimuoverla, è sufficiente scrivere:

sg.removeChild(no)

Salvare il grafo della scaena con una rotazione in una serie di 36 file negli assi X Y Z.

import math
import time
from FreeCAD import Base
from pivy import coin

size=(1000,1000)
dirname = "C:/Temp/animation/"
steps=36
angle=2*math.pi/steps

matX=Base.Matrix()
matX.rotateX(angle)
stepsX=Base.Placement(matX).Rotation

matY=Base.Matrix()
matY.rotateY(angle)
stepsY=Base.Placement(matY).Rotation

matZ=Base.Matrix()
matZ.rotateZ(angle)
stepsZ=Base.Placement(matZ).Rotation

view=Gui.ActiveDocument.ActiveView
cam=view.getCameraNode()
rotCamera=Base.Rotation(*cam.orientation.getValue().getValue())

# this sets the lookat point to the center of circumsphere of the global bounding box
view.fitAll()

# the camera's position, i.e. the user's eye point
position=Base.Vector(*cam.position.getValue().getValue())
distance=cam.focalDistance.getValue()

# view direction
vec=rotCamera.multVec(Base.Vector(0,0,-1))

# this is the point on the screen the camera looks at
# when rotating the camera we should make this point fix
lookat=position+vec*distance

# around x axis
for i in range(steps):
    rotCamera=stepsX.multiply(rotCamera)
    cam.orientation.setValue(*rotCamera.Q)
    vec=rotCamera.multVec(Base.Vector(0,0,-1))
    pos=lookat-vec*distance
    cam.position.setValue(pos.x,pos.y,pos.z)
    Gui.updateGui()
    time.sleep(0.3)
    view.saveImage(dirname+"x-%d.png" % i,*size)

# around y axis
for i in range(steps):
    rotCamera=stepsY.multiply(rotCamera)
    cam.orientation.setValue(*rotCamera.Q)
    vec=rotCamera.multVec(Base.Vector(0,0,-1))
    pos=lookat-vec*distance
    cam.position.setValue(pos.x,pos.y,pos.z)
    Gui.updateGui()
    time.sleep(0.3)
    view.saveImage(dirname+"y-%d.png" % i,*size)

# around z axis
for i in range(steps):
    rotCamera=stepsZ.multiply(rotCamera)
    cam.orientation.setValue(*rotCamera.Q)
    vec=rotCamera.multVec(Base.Vector(0,0,-1))
    pos=lookat-vec*distance
    cam.position.setValue(pos.x,pos.y,pos.z)
    Gui.updateGui()
    time.sleep(0.3)
    view.saveImage(dirname+"z-%d.png" % i,*size)

Aggiungere dei widget personalizzati all'interfaccia

È possibile creare widget personalizzati con Qt designer, trasformarli in uno script Python e poi caricarli nell'interfaccia di FreeCAD con PySide.

Il codice Python prodotto dal compilatore Ui di Python (lo strumento che converte i file .ui di Qt-designer nel codice Python) appare in genere come questo (è semplice, si può anche codificare direttamente in 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))

Dopo, basta creare un riferimento alla finestra Qt di FreeCAD, inserire un widget personalizzato in essa, e "trasformare" questo widget nel proprio con il codice Ui che abbiamo appena creato:

app = QtGui.qApp
FCmw = app.activeWindow() # the active qt window, = the freecad window since we are inside it
# FCmw = FreeCADGui.getMainWindow() # use this line if the 'addDockWidget' error is declared
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

Aggiungere una scheda alla Combo View

Il seguente codice consente di aggiungere una nuova scheda nel pannello ComboView (vista combinata) di FreeCAD, oltre le schede standard "Progetto" e "Attività" . Questo codice utilizza anche il modulo UIC per caricare un file ui direttamente nella nuova scheda.

# create new Tab in ComboView
from PySide import QtGui,QtCore
#from PySide import uic

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)
       elif str(i.objectName()) == "Python Console":
           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)

Abilitare o disabilitare una finestra

from PySide import QtGui
mw=FreeCADGui.getMainWindow()
dws=mw.findChildren(QtGui.QDockWidget)

# objectName may be :
# "Report view"
# "Tree view"
# "Property view"
# "Selection view"
# "Combo View"
# "Python console"
# "draftToolbar"

for i in dws:
  if i.objectName() == "Report view":
    dw=i
    break

va=dw.toggleViewAction()
va.setChecked(True)        # True or False
dw.setVisible(True)        # True or False

Aprire una specifica pagina Web

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

Ottenere il contenuto HTML di una pagina web aperta

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

Reperire e utilizzare le coordinate di 3 punti o oggetti selezionati

# -*- coding: utf-8 -*-
# the line above to put the accentuated in the remarks
# If this line is missing, an error will be returned
# extract and use the coordinates of 3 objects selected
import Part, FreeCAD, math, PartGui, FreeCADGui
from FreeCAD import Base, Console
sel = FreeCADGui.Selection.getSelection() # " sel " contains the items selected
if len(sel)!=3 :
  # If there are no 3 objects selected, an error is displayed in the report view
  # The \r and \n at the end of line mean return and the newline CR + LF.
  Console.PrintError("Select 3 points exactly\r\n")
else :
  points=[]
  for obj in sel:
    points.append(obj.Shape.BoundBox.Center)

  for pt in points:
    # display of the coordinates in the report view
    Console.PrintMessage(str(pt.x)+"\r\n")
    Console.PrintMessage(str(pt.y)+"\r\n")
    Console.PrintMessage(str(pt.z)+"\r\n")

  Console.PrintMessage(str(pt[1]) + "\r\n")

Lista di oggetti

# -*- coding: utf-8 -*-
import FreeCAD,Draft
# List all objects of the document
doc = FreeCAD.ActiveDocument
objs = FreeCAD.ActiveDocument.Objects
#App.Console.PrintMessage(str(objs) + "\n")
#App.Console.PrintMessage(str(len(FreeCAD.ActiveDocument.Objects)) + " Objects"  + "\n")

for obj in objs:
    a = obj.Name                                             # list the Name  of the object  (not modifiable)
    b = obj.Label                                            # list the Label of the object  (modifiable)
    try:
        c = obj.LabelText                                    # list the LabeText of the text (modifiable)
        App.Console.PrintMessage(str(a) +" "+ str(b) +" "+ str(c) + "\n") # Displays the Name the Label and the text
    except:
        App.Console.PrintMessage(str(a) +" "+ str(b) + "\n") # Displays the Name and the Label of the object

#doc.removeObject("Box") # Clears the designated object

Ottenere la dimensione di un oggetto, dato il suo nome

for edge in FreeCAD.ActiveDocument.MyObjectName.Shape.Edges: # replace "MyObjectName" for list
    print edge.Length


Funzione residente per una azione con un clic del mouse

Here with SelObserver on a object select

# -*- coding: utf-8 -*-
# causes an action to the mouse click on an object
# This function remains resident (in memory) with the function "addObserver(s)"
# "removeObserver(s) # Uninstalls the resident function
class SelObserver:
    def setPreselection(self,doc,obj,sub):                # Preselection object
        App.Console.PrintMessage(str(sub)+ "\n")          # The part of the object name

    def addSelection(self,doc,obj,sub,pnt):               # Selection object
        App.Console.PrintMessage("addSelection"+ "\n")
        App.Console.PrintMessage(str(doc)+ "\n")          # Name of the document
        App.Console.PrintMessage(str(obj)+ "\n")          # Name of the object
        App.Console.PrintMessage(str(sub)+ "\n")          # The part of the object name
        App.Console.PrintMessage(str(pnt)+ "\n")          # Coordinates of the object
        App.Console.PrintMessage("______"+ "\n")

    def removeSelection(self,doc,obj,sub):                # Delete the selected object
        App.Console.PrintMessage("removeSelection"+ "\n")

    def setSelection(self,doc):                           # Selection in ComboView
        App.Console.PrintMessage("setSelection"+ "\n")

    def clearSelection(self,doc):                         # If click on the screen, clear the selection
        App.Console.PrintMessage("clearSelection"+ "\n")  # If click on another object, clear the previous object
s =SelObserver()
FreeCADGui.Selection.addObserver(s)                       # install the function mode resident
#FreeCADGui.Selection.removeObserver(s)                   # Uninstall the resident function

Other example with ViewObserver on a object select or view

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 __init__(self, view):
       self.view = view
   
   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")
           pnt = self.view.getPoint(pos)
           FreeCAD.Console.PrintMessage("World coordinates: " + str(pnt) + "\n")
           info = self.view.getObjectInfo(pos)
           FreeCAD.Console.PrintMessage("Object info: " + str(info) + "\n")

o = ViewObserver(v)
c = v.addEventCallback("SoMouseButtonEvent",o.logPosition)

Trovare-selezionare tutti gli elementi sotto il cursore

from pivy import coin
import FreeCADGui

def mouse_over_cb( event_callback):
    event = event_callback.getEvent()
    pos = event.getPosition().getValue()
    listObjects = FreeCADGui.ActiveDocument.ActiveView.getObjectsInfo((int(pos[0]),int(pos[1])))
    obj = []
    if listObjects:
        FreeCAD.Console.PrintMessage("\n *** Objects under mouse pointer ***")
        for o in listObjects:
            label = str(o["Object"])
            if not label in obj:
                obj.append(label)
        FreeCAD.Console.PrintMessage("\n"+str(obj))


view = FreeCADGui.ActiveDocument.ActiveView

mouse_over = view.addEventCallbackPivy( coin.SoLocation2Event.getClassTypeId(), mouse_over_cb )

# to remove Callback :
#view.removeEventCallbackPivy( coin.SoLocation2Event.getClassTypeId(), mouse_over)

####
#The easy way is probably to use FreeCAD's selection.
#FreeCADGui.ActiveDocument.ActiveView.getObjectsInfo(mouse_coords)

####
#you get that kind of result :
#'Document': 'Unnamed', 'Object': 'Box', 'Component': 'Face2', 'y': 8.604081153869629, 'x': 21.0, 'z': 8.553047180175781

####
#You can use this data to add your element to FreeCAD's selection :
#FreeCADGui.Selection.addSelection(FreeCAD.ActiveDocument.Box,'Face2',21.0,8.604081153869629,8.553047180175781)

Elencare i componenti di un oggetto

Questa funzione elenca i componenti ed estrae le coordinate XYZ di un oggetto, i bordi (edge) e le loro lunghezze, le sue facce e la loro superficie.

# -*- coding: utf-8 -*-
# This function list the components of an object
# and extract this object its XYZ coordinates,
# its edges and their lengths center of mass and coordinates
# its faces and their center of mass
# its faces and their surfaces and coordinates
# 8/05/2014

import Draft,Part
def detail():
    sel = FreeCADGui.Selection.getSelection()   # Select an object
    if len(sel) != 0:                           # If there is a selection then
        Vertx=[]
        Edges=[]
        Faces=[]
        compt_V=0
        compt_E=0
        compt_F=0
        pas    =0
        perimetre = 0.0   
        EdgesLong = []

        # Displays the "Name" and the "Label" of the selection
        App.Console.PrintMessage("Selection > " + str(sel[0].Name) + "  " + str(sel[0].Label) +"\n"+"\n")

        for j in enumerate(sel[0].Shape.Edges):                                     # Search the "Edges" and their lengths
            compt_E+=1
            Edges.append("Edge%d" % (j[0]+1))
            EdgesLong.append(str(sel[0].Shape.Edges[compt_E-1].Length))
            perimetre += (sel[0].Shape.Edges[compt_E-1].Length)                     # calculates the perimeter

            # Displays the "Edge" and its length
            App.Console.PrintMessage("Edge"+str(compt_E)+" Length > "+str(sel[0].Shape.Edges[compt_E-1].Length)+"\n")

            # Displays the "Edge" and its center mass
            App.Console.PrintMessage("Edge"+str(compt_E)+" Center > "+str(sel[0].Shape.Edges[compt_E-1].CenterOfMass)+"\n")

            num = sel[0].Shape.Edges[compt_E-1].Vertexes[0]
            Vertx.append("X1: "+str(num.Point.x))
            Vertx.append("Y1: "+str(num.Point.y))
            Vertx.append("Z1: "+str(num.Point.z))
            # Displays the coordinates 1
            App.Console.PrintMessage("X1: "+str(num.Point[0])+" Y1: "+str(num.Point[1])+" Z1: "+str(num.Point[2])+"\n")

            try:
                num = sel[0].Shape.Edges[compt_E-1].Vertexes[1]
                Vertx.append("X2: "+str(num.Point.x))
                Vertx.append("Y2: "+str(num.Point.y))
                Vertx.append("Z2: "+str(num.Point.z))
            except:
                Vertx.append("-")
                Vertx.append("-")
                Vertx.append("-")
            # Displays the coordinates 2
            App.Console.PrintMessage("X2: "+str(num.Point[0])+" Y2: "+str(num.Point[1])+" Z2: "+str(num.Point[2])+"\n")

            App.Console.PrintMessage("\n")
        App.Console.PrintMessage("Perimeter of the form  : "+str(perimetre)+"\n") 

        App.Console.PrintMessage("\n")
        FacesSurf = []
        for j in enumerate(sel[0].Shape.Faces):                                      # Search the "Faces" and their surface
            compt_F+=1
            Faces.append("Face%d" % (j[0]+1))
            FacesSurf.append(str(sel[0].Shape.Faces[compt_F-1].Area))

            # Displays 'Face' and its surface
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Surface "+str(sel[0].Shape.Faces[compt_F-1].Area)+"\n")

            # Displays 'Face' and its CenterOfMass
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Center  "+str(sel[0].Shape.Faces[compt_F-1].CenterOfMass)+"\n")

            # Displays 'Face' and its Coordinates
            FacesCoor = []
            fco = 0
            for f0 in sel[0].Shape.Faces[compt_F-1].Vertexes:                        # Search the Vertexes of the face
                fco += 1
                FacesCoor.append("X"+str(fco)+": "+str(f0.Point.x))
                FacesCoor.append("Y"+str(fco)+": "+str(f0.Point.y))
                FacesCoor.append("Z"+str(fco)+": "+str(f0.Point.z))

            # Displays 'Face' and its Coordinates
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Coordinate"+str(FacesCoor)+"\n")

            # Displays 'Face' and its Volume
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Volume  "+str(sel[0].Shape.Faces[compt_F-1].Volume)+"\n")
            App.Console.PrintMessage("\n")

        # Displays the total surface of the form
        App.Console.PrintMessage("Surface of the form    : "+str(sel[0].Shape.Area)+"\n")

        # Displays the total Volume of the form
        App.Console.PrintMessage("Volume  of the form    : "+str(sel[0].Shape.Volume)+"\n")

detail()

List the PropertiesList

import FreeCADGui
from FreeCAD import Console
o = App.ActiveDocument.ActiveObject
op = o.PropertiesList
for p in op:
    Console.PrintMessage("Property: "+ str(p)+ " Value: " + str(o.getPropertyByName(p))+"\r\n")

Aggiungere una Proprietà "Comment"

import Draft
obj = FreeCADGui.Selection.getSelection()[0]
obj.addProperty("App::PropertyString","GComment","Draft","Font name").GComment = "Comment here"
App.activeDocument().recompute()

Ricerca e estrazione di dati

Esempi di ricerca e decodifica di informazioni su un oggetto.

Ogni sezione separata da "############" è indipendente e può essere copiata direttamente nella console Python, o in una macro o usata come macro a sè stante. La descrizione della macro si trova nel commento.

Le informazioni ricercate in questo modo sono visualizzate nella finestra dei rapporti attivabile con Visualizza -> Viste -> Report

# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
 
# Exemples de recherche et de decodage d'informations sur un objet
# Chaque section peut etre copiee directement dans la console Python ou dans une macro ou utilisez la macro tel quel
# Certaines commandes se repetent seul l'approche est differente
# L'affichage se fait dans la Vue rapport : Menu Affichage > Vues > Vue rapport
#
# Examples of research and decoding information on an object
# Each section can be copied directly into the Python console, or in a macro or uses this macro
# Certain commands as repeat alone approach is different
# Displayed on Report view : Menu View > Views > report view
#
# rev:30/08/2014:29/09/2014:17/09/2015
 
from FreeCAD import Base
import DraftVecUtils, Draft, Part
 
mydoc = FreeCAD.activeDocument().Name                                     # Name of active Document
App.Console.PrintMessage("Active docu    : "+(mydoc)+"\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
object_Label = sel[0].Label                                               # Label of the object (modifiable)
App.Console.PrintMessage("object_Label   : "+(object_Label)+"\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
App.Console.PrintMessage("sel            : "+str(sel[0])+"\n\n")          # sel[0] first object selected
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
object_Name  = sel[0].Name                                                # Name of the object (not modifiable)
App.Console.PrintMessage("object_Name    : "+str(object_Name)+"\n\n")
##################################################################################
 
try:
    SubElement = FreeCADGui.Selection.getSelectionEx()                    # sub element name with getSelectionEx()
    element_ = SubElement[0].SubElementNames[0]                           # name of 1 element selected
    App.Console.PrintMessage("elementSelec   : "+str(element_)+"\n\n")            
except:
    App.Console.PrintMessage("Oups"+"\n\n")            
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
App.Console.PrintMessage("sel            : "+str(sel[0])+"\n\n")          # sel[0] first object selected
##################################################################################
 
SubElement = FreeCADGui.Selection.getSelectionEx()                        # sub element name with getSelectionEx()
App.Console.PrintMessage("SubElement     : "+str(SubElement[0])+"\n\n")   # name of sub element
##################################################################################

SubElement = Gui.Selection.getSelectionEx()[0].SubObjects[0].Length       # sub element or element name with getSelectionEx()
App.Console.PrintMessage("SubElement length: "+str(length)+"\n")          # length
##################################################################################

sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
i = 0
for j in enumerate(sel[0].Shape.Edges):                                   # list all Edges
    i += 1
    App.Console.PrintMessage("Edges n : "+str(i)+"\n")
    a = sel[0].Shape.Edges[j[0]].Vertexes[0]
    App.Console.PrintMessage("X1             : "+str(a.Point.x)+"\n")     # coordinate XYZ first point
    App.Console.PrintMessage("Y1             : "+str(a.Point.y)+"\n")
    App.Console.PrintMessage("Z1             : "+str(a.Point.z)+"\n")
    try:
        a = sel[0].Shape.Edges[j[0]].Vertexes[1]
        App.Console.PrintMessage("X2             : "+str(a.Point.x)+"\n") # coordinate XYZ second point
        App.Console.PrintMessage("Y2             : "+str(a.Point.y)+"\n")
        App.Console.PrintMessage("Z2             : "+str(a.Point.z)+"\n")
    except:
        App.Console.PrintMessage("Oups"+"\n")    
App.Console.PrintMessage("\n")    
##################################################################################
 
try:
    SubElement = FreeCADGui.Selection.getSelectionEx()                                        # sub element name with getSelectionEx()
    subElementName = Gui.Selection.getSelectionEx()[0].SubElementNames[0]                     # sub element name with getSelectionEx()
    App.Console.PrintMessage("subElementName : "+str(subElementName)+"\n")
    
    subObjectLength = Gui.Selection.getSelectionEx()[0].SubObjects[0].Length                  # sub element Length
    App.Console.PrintMessage("subObjectLength: "+str(subObjectLength)+"\n\n")
    
    subObjectX1 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[0].Point.x         # sub element coordinate X1
    App.Console.PrintMessage("subObject_X1   : "+str(subObjectX1)+"\n")
    subObjectY1 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[0].Point.y         # sub element coordinate Y1
    App.Console.PrintMessage("subObject_Y1   : "+str(subObjectY1)+"\n")
    subObjectZ1 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[0].Point.z         # sub element coordinate Z1
    App.Console.PrintMessage("subObject_Z1   : "+str(subObjectZ1)+"\n\n")

    try:
        subObjectX2 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[1].Point.x     # sub element coordinate X2
        App.Console.PrintMessage("subObject_X2   : "+str(subObjectX2)+"\n")
        subObjectY2 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[1].Point.y     # sub element coordinate Y2
        App.Console.PrintMessage("subObject_Y2   : "+str(subObjectY2)+"\n")
        subObjectZ2 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[1].Point.z     # sub element coordinate Z2
        App.Console.PrintMessage("subObject_Z2   : "+str(subObjectZ2)+"\n\n")
    except:
        App.Console.PrintMessage("Oups"+"\n\n")            

    subObjectBoundBox = Gui.Selection.getSelectionEx()[0].SubObjects[0].BoundBox              # sub element BoundBox coordinates
    App.Console.PrintMessage("subObjectBBox  : "+str(subObjectBoundBox)+"\n")
    
    subObjectBoundBoxCenter = Gui.Selection.getSelectionEx()[0].SubObjects[0].BoundBox.Center # sub element BoundBoxCenter
    App.Console.PrintMessage("subObjectBBoxCe: "+str(subObjectBoundBoxCenter)+"\n")
    
    surfaceFace = Gui.Selection.getSelectionEx()[0].SubObjects[0].Area                        # Area of the face selected
    App.Console.PrintMessage("surfaceFace    : "+str(surfaceFace)+"\n\n")
except:
    App.Console.PrintMessage("Oups"+"\n\n")            
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
surface = sel[0].Shape.Area                                               # Area object complete
App.Console.PrintMessage("surfaceObjet   : "+str(surface)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
CenterOfMass = sel[0].Shape.CenterOfMass                                  # Center of Mass of the object
App.Console.PrintMessage("CenterOfMass   : "+str(CenterOfMass)+"\n")
App.Console.PrintMessage("CenterOfMassX  : "+str(CenterOfMass[0])+"\n")   # coordinates [0]=X [1]=Y [2]=Z
App.Console.PrintMessage("CenterOfMassY  : "+str(CenterOfMass[1])+"\n")
App.Console.PrintMessage("CenterOfMassZ  : "+str(CenterOfMass[2])+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
for j in enumerate(sel[0].Shape.Faces):                                   # List alles faces of the object
    App.Console.PrintMessage("Face           : "+str("Face%d" % (j[0]+1))+"\n")
App.Console.PrintMessage("\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
volume_ = sel[0].Shape.Volume                                             # Volume of the object
App.Console.PrintMessage("volume_        : "+str(volume_)+"\n\n")
##################################################################################
 
objs = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()

if len(objs) >= 1:
    if hasattr(objs[0], "Shape"):
        s = objs[0].Shape
    elif hasattr(objs[0], "Mesh"):      # upgrade with wmayer thanks #http://forum.freecadweb.org/viewtopic.php?f=13&t=22331
        s = objs[0].Mesh
    elif hasattr(objs[0], "Points"):
        s = objs[0].Points

#sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
#boundBox_= sel[0].Shape.BoundBox                                          # BoundBox of the object
boundBox_= s.BoundBox                                                      # BoundBox of the object
App.Console.PrintMessage("boundBox_      : "+str(boundBox_)+"\n")
 
boundBoxLX  = boundBox_.XLength                                           # Length x boundBox rectangle
boundBoxLY  = boundBox_.YLength                                           # Length y boundBox rectangle
boundBoxLZ  = boundBox_.ZLength                                           # Length z boundBox rectangle
boundBoxDiag= boundBox_.DiagonalLength                                    # Diagonal Length boundBox rectangle

App.Console.PrintMessage("boundBoxLX     : "+str(boundBoxLX)+"\n")
App.Console.PrintMessage("boundBoxLY     : "+str(boundBoxLY)+"\n")
App.Console.PrintMessage("boundBoxLZ     : "+str(boundBoxLZ)+"\n")
App.Console.PrintMessage("boundBoxDiag   : "+str(boundBoxDiag)+"\n\n")

##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement                                               # Placement Vector XYZ and Yaw-Pitch-Roll
App.Console.PrintMessage("Placement      : "+str(pl)+"\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement.Base                                          # Placement Vector XYZ
App.Console.PrintMessage("PlacementBase  : "+str(pl)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
oripl_X = sel[0].Placement.Base[0]                                        # decode Placement X
oripl_Y = sel[0].Placement.Base[1]                                        # decode Placement Y
oripl_Z = sel[0].Placement.Base[2]                                        # decode Placement Z
 
App.Console.PrintMessage("oripl_X        : "+str(oripl_X)+"\n")
App.Console.PrintMessage("oripl_Y        : "+str(oripl_Y)+"\n")
App.Console.PrintMessage("oripl_Z        : "+str(oripl_Z)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
rotation = sel[0].Placement.Rotation                                      # decode Placement Rotation
App.Console.PrintMessage("rotation              : "+str(rotation)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement.Rotation                                      # decode Placement Rotation other method
App.Console.PrintMessage("Placement Rot         : "+str(pl)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement.Rotation.Angle                                # decode Placement Rotation Angle
App.Console.PrintMessage("Placement Rot Angle   : "+str(pl)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
Rot_0 = sel[0].Placement.Rotation.Q[0]                                    # decode Placement Rotation Q
App.Console.PrintMessage("Rot_0         : "+str(Rot_0)+ " rad ,  "+str(180 * Rot_0 / 3.1416)+" deg "+"\n")
 
Rot_1 = sel[0].Placement.Rotation.Q[1]                                    # decode Placement Rotation 1
App.Console.PrintMessage("Rot_1         : "+str(Rot_1)+ " rad ,  "+str(180 * Rot_1 / 3.1416)+" deg "+"\n")
 
Rot_2 = sel[0].Placement.Rotation.Q[2]                                    # decode Placement Rotation 2
App.Console.PrintMessage("Rot_2         : "+str(Rot_2)+ " rad ,  "+str(180 * Rot_2 / 3.1416)+" deg "+"\n")
 
Rot_3 = sel[0].Placement.Rotation.Q[3]                                    # decode Placement Rotation 3
App.Console.PrintMessage("Rot_3         : "+str(Rot_3)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
Yaw   = sel[0].Shape.Placement.Rotation.toEuler()[0]                      # decode angle Euler Yaw (Z)
App.Console.PrintMessage("Yaw            : "+str(Yaw)+"\n")
Pitch = sel[0].Shape.Placement.Rotation.toEuler()[1]                      # decode angle Euler Pitch (Y)
App.Console.PrintMessage("Pitch          : "+str(Pitch)+"\n")
Roll  = sel[0].Shape.Placement.Rotation.toEuler()[2]                      # decode angle Euler Roll (X)
App.Console.PrintMessage("Roll           : "+str(Roll)+"\n\n")
##################################################################################

import DraftGeomUtils
sel = FreeCADGui.Selection.getSelection()
vecteur = DraftGeomUtils.findMidpoint(sel[0].Shape.Edges[0])              # find Midpoint
App.Console.PrintMessage(vecteur)
Draft.makePoint(vecteur)
##################################################################################

Ricerca manuale di un elemento dall'etichetta

# Extract the coordinate X,Y,Z and Angle giving the label 
App.Console.PrintMessage("Base.x       : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.x)+"\n")
App.Console.PrintMessage("Base.y       : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.y)+"\n")
App.Console.PrintMessage("Base.z       : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.z)+"\n")
App.Console.PrintMessage("Base.Angle   : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Rotation.Angle)+"\n\n")
##################################################################################

Note: Di solito gli angoli sono espressi in radianti da convertire con:

  1. da gradi a radianti :
    • angolo in radianti = pi * (angolo in gradi) / 180
    • angolo in radianti = math.radians(angolo in gradi)
  2. da radianti a gradi :
    • angolo in gradi = 180 * (angolo in radianti) / pi
    • angolo in gradi = math.degrees(angolo in radianti)

Coordinate Cartesiane

Questo codice visualizza le coordinate cartesiane dell'elemento selezionato.

Modificare il valore di "numberOfPoints" se si desidera un diverso numero di punti (modificare la precisione)

numberOfPoints = 100                                                         # Decomposition number (or precision you can change)
selectedEdge = FreeCADGui.Selection.getSelectionEx()[0].SubObjects[0].copy() # select one element
points  = selectedEdge.discretize(numberOfPoints)                            # discretize the element
i=0
for p in points:                                                             # list and display the coordinates
    i+=1
    print i, " X", p.x, " Y", p.y, " Z", p.z

Altro metodo per visualizzare "Int" e "Float" (interi e valori in virgola mobile)

import Part
from FreeCAD import Base

c=Part.makeCylinder(2,10)        # create the circle
Part.show(c)                     # display the shape

# slice accepts two arguments:
#+ the normal of the cross section plane
#+ the distance from the origin to the cross section plane. Here you have to find a value so that the plane intersects your object
s=c.slice(Base.Vector(0,1,0),0)  # 

# here the result is a single wire
# depending on the source object this can be several wires
s=s[0]

# if you only need the vertexes of the shape you can use
v=[]
for i in s.Vertexes:
    v.append(i.Point)

# but you can also sub-sample the section to have a certain number of points (int) ...
p1=s.discretize(20)
ii=0
for i in p1:
    ii+=1
    print i                                              # Vector()
    print ii, ": X:", i.x, " Y:", i.y, " Z:", i.z        # Vector decode
Draft.makeWire(p1,closed=False,face=False,support=None)  # to see the difference accuracy (20)

## uncomment to use
#import Draft
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # first transform the DWire in Wire         "downgrade"
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # second split the Wire in single objects   "downgrade"
#
##Draft.upgrade(FreeCADGui.Selection.getSelection(),delete=True) # to attach lines contiguous SELECTED use "upgrade"


# ... or define a sampling distance (float)
p2=s.discretize(0.5)
ii=0
for i in p2:
    ii+=1
    print i                                              # Vector()
    print ii, ": X:", i.x, " Y:", i.y, " Z:", i.z        # Vector decode 
Draft.makeWire(p2,closed=False,face=False,support=None)  # to see the difference accuracy (0.5)

## uncomment to use
#import Draft
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # first transform the DWire in Wire         "downgrade"
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # second split the Wire in single objects   "downgrade"
#
##Draft.upgrade(FreeCADGui.Selection.getSelection(),delete=True) # to attach lines contiguous SELECTED use "upgrade"

Selezionare tutti gli oggetti nel documento

import FreeCAD
for obj in FreeCAD.ActiveDocument.Objects:
    print obj.Name                                # display the object Name
    objName = obj.Name
    obj = App.ActiveDocument.getObject(objName)
    Gui.Selection.addSelection(obj)               # select the object

Selezionare la faccia di un oggetto

# select one face of the object
import FreeCAD, Draft
App=FreeCAD
nameObject = "Box"                             # objet
faceSelect = "Face3"                           # face to selection
loch=App.ActiveDocument.getObject(nameObject)  # objet
Gui.Selection.clearSelection()                 # clear all selection
Gui.Selection.addSelection(loch,faceSelect)    # select the face specified
s = Gui.Selection.getSelectionEx()
#Draft.makeFacebinder(s)                       #

Creare un oggetto della posizione della fotocamera

# create one object of the position to camera with "getCameraOrientation()"
# the object is still facing the screen
import Draft

plan = FreeCADGui.ActiveDocument.ActiveView.getCameraOrientation()
plan = str(plan)
###### extract data
a    = ""
for i in plan:
    if i in ("0123456789e.- "):
        a+=i
a = a.strip(" ")
a = a.split(" ")
####### extract data

#print a
#print a[0]
#print a[1]
#print a[2]
#print a[3]

xP = float(a[0])
yP = float(a[1])
zP = float(a[2])
qP = float(a[3])

pl = FreeCAD.Placement()
pl.Rotation.Q = (xP,yP,zP,qP)         # rotation of object
pl.Base = FreeCAD.Vector(0.0,0.0,0.0) # here coordinates XYZ of Object
rec = Draft.makeRectangle(length=10.0,height=10.0,placement=pl,face=False,support=None) # create rectangle
#rec = Draft.makeCircle(radius=5,placement=pl,face=False,support=None)                   # create circle
print rec.Name

stesso codice semplificato

import Draft
pl = FreeCAD.Placement()
pl.Rotation = FreeCADGui.ActiveDocument.ActiveView.getCameraOrientation()
pl.Base = FreeCAD.Vector(0.0,0.0,0.0)
rec = Draft.makeRectangle(length=10.0,height=10.0,placement=pl,face=False,support=None)

Trovare il vettore normale alla superficie

Questo esempio mostra come trovare vettore normale alla superficie trovando prima i parametri u, v di un punto sulla superficie e utilizzando poi i parametri u, v per trovare il vettore normale

def normal(self):
   ss=FreeCADGui.Selection.getSelectionEx()[0].SubObjects[0].copy()#SubObjects[0] is the edge list
   points  = ss.discretize(3.0)#points on the surface edge, 
             #this example just use points on the edge for example. 
             #However point is not necessary on the edge, it can be anywhere on the surface. 
   face=FreeCADGui.Selection.getSelectionEx()[0].SubObjects[1]
   for pp in points:
      pt=FreeCAD.Base.Vector(pp.x,pp.y,pp.z)#a point on the surface edge
      uv=face.Surface.parameter(pt)# find the surface u,v parameter of a point on the surface edge
      u=uv[0]
      v=uv[1]
      normal=face.normalAt(u,v)#use u,v to find normal vector
      print normal
      line=Part.makeLine((pp.x,pp.y,pp.z), (normal.x,normal.y,normal.z))
      Part.show(line)

Leggere e scrivere una Expression

import Draft
doc = FreeCAD.ActiveDocument

pl=FreeCAD.Placement()
pl.Rotation.Q=(0.0,-0.0,-0.0,1.0)
pl.Base=FreeCAD.Vector(0.0,0.0,0.0)
obj = Draft.makeCircle(radius=1.0,placement=pl,face=False,support=None)    # create circle

print obj.PropertiesList                                                   # properties disponible in the obj

doc.getObject(obj.Name).setExpression('Radius', u'2mm')                    # modify the radius
doc.getObject(obj.Name).setExpression('Placement.Base.x', u'10mm')         # modify the placement 
doc.getObject(obj.Name).setExpression('FirstAngle', u'90')                 # modify the first angle
doc.recompute()

expressions = obj.ExpressionEngine                                         # read the expression list
print expressions

for i in expressions:                                                      # list and separate the data expression
    print i[0]," = ",i[1]


Ottieni il vettore normale di una superficie da un file STL

def getNormal(cb):
    if cb.getEvent().getState() == coin.SoButtonEvent.UP:
        pp = cb.getPickedPoint()
        if pp:
            vec = pp.getNormal().getValue()
            index = coin.cast(pp.getDetail(), "SoFaceDetail").getFaceIndex()
            print ("Normal: {}, Face index: {}".format(str(vec), index))

from pivy import coin
meth=Gui.ActiveDocument.ActiveView.addEventCallbackPivy(coin.SoMouseButtonEvent.getClassTypeId(), getNormal)

hai finito quindi fai questo per uscire:

Gui.ActiveDocument.ActiveView.removeEventCallbackPivy(coin.SoMouseButtonEvent.getClassTypeId(), meth)
Arrow-left.svg Incorporare FreeCAD Pagina precedente:
Pagina successiva: Funzione per disegnare linee Arrow-right.svg


Arrow-left.svg Modelli di codici Pagina precedente:
Pagina successiva: Creazione di dialoghi Arrow-right.svg

Questa pagina mostra come si possono facilmente costruire delle funzionalità avanzate con Python.

In questo esercizio, costruiremo un nuovo strumento che disegna una linea partendo da due punti cliccati nella vista 3D.

Questo strumento può essere collegato a un comando di FreeCAD, e tale comando può essere chiamato da un qualsiasi elemento dell'interfaccia, ad esempio da una voce di menu o da un pulsante in una barra degli strumenti.

Lo script principale

Per prima cosa scriviamo uno script che contenga tutta la nostra funzionalità.

Dopo, salviamo questo script in un file e lo importiamo in FreeCAD, in modo che tutte le classi e le funzioni che scriviamo diventino disponibili in FreeCAD.

Lanciamo perciò il nostro editor di testo preferito, e digitiamo le seguenti righe:

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)

Spiegazione dettagliata

import Part, FreeCADGui
from pivy.coin import *

In Python, quando si desidera utilizzare le funzioni di un altro modulo è necessario importarlo.

Nel nostro caso, abbiamo bisogno delle funzioni del Modulo Parte per creare la linea, e del modulo Gui (FreeCADGui) per accedere alla visualizzazione 3D.

Inoltre, abbiamo anche bisogno del contenuto completo della libreria di Coin, in modo da poter utilizzare direttamente tutti gli oggetti Coin, come, ad esempio, SoMouseButtonEvent, ecc ..

class line:

Qui definiamo la nostra classe principale.

Perché utilizzare una classe e non una funzione? Il motivo è che abbiamo bisogno che il nostro strumento rimanga "vivo" mentre aspettiamo che l'utente clicchi sullo schermo.

Una funzione termina quando il suo compito è stato svolto, invece un oggetto (una classe definisce un oggetto) rimane attivo finché non viene distrutto.

"this class will create a line after the user clicked 2 points on the screen"

In Python, ogni classe o funzione può avere una stringa di descrizione.

In FreeCAD, questo è particolarmente utile perché quando chiameremo la classe nell'interprete, la stringa di descrizione verrà visualizzata come tooltip (nota di descrizione o aiuto).

def __init__(self):

Le classi di Python possono sempre contenere una funzione __init__, che viene eseguita quando la classe viene chiamata per creare un oggetto. Quindi, metteremo qui tutto quello che vogliamo che accada quando il nostro strumento line (linea) inizia.

self.view = FreeCADGui.ActiveDocument.ActiveView

In una classe, di solito si aggiunge self. prima di un nome di variabile, in modo che sia facilmente accessibile a tutte le funzioni dentro e fuori questa classe. In questo script, usiamo self.view per accedere e manipolare la vista 3D attiva.

self.stack = []

Qui creiamo una lista vuota per archiviare i punti 3D inviati dalla funzione getpoint.

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

Questa è la parte importante.

Dato che in realtà si tratta una scena Coin3d, FreeCAD utilizza il meccanismo di callback (richiamo) di Coin, il quale permette di chiamare una funzione ogni volta che nella scena accade un determinato evento.

Nel nostro caso, stiamo creando un callback per gli eventi SoMouseButtonEvent e li colleghiamo alla funzione getpoint. Adesso, ogni volta che un pulsante del mouse viene premuto o rilasciato, viene eseguita la funzione getpoint.

Notare che alla addEventCallbackPivy() esiste anche un'alternativa, chiamata addEventCallback() la quale dispensa dall'uso di pivy. Ma, dal momento che pivy è un modo molto efficace e naturale per accedere a ogni parte di una scena di Coin, è meglio utilizzarlo il più possibile!

def getpoint(self,event_cb):

Ora definiamo la funzione getpoint, che sarà eseguita quando un pulsante del mouse verrà premuto in una vista 3D. Questa funzione riceverà un argomento, che chiamiamo event_cb.

Da questo evento callback possiamo accedere all'oggetto event, che contiene diverse parti di informazioni

Per maggiori informazioni sugli eventi controllabili consultate questa pagina.

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

La funzione getpoint viene chiamata ogni volta che un pulsante del mouse viene premuto o rilasciato. Invece, noi vogliamo definire un punto 3D solo quando viene premuto (altrimenti otteniamo due punti 3D molto vicini l'uno all'altro). Pertanto quì dobbiamo verificare e stabilire questo.

pos = event.getPosition()

Qui otteniamo le coordinate dello schermo nella posizione del cursore del mouse

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

Questa funzione ci fornisce un vettore di FreeCAD (x, y, z) contenente il punto 3D che giace sul piano focale, esattamente sotto il cursore del mouse. Se siamo in vista camera, immaginiamo un raggio proveniente dalla fotocamera, passante per il cursore del mouse, che colpisce il piano focale. Questo è il nostro punto 3D. Se siamo in vista ortogonale, il raggio è parallelo alla direzione di visualizzazione.

self.stack.append(point)

Aggiungiamo il nostro nuovo punto nella pila (stack)

if len(self.stack) == 2:

Abbiamo già abbastanza punti? Se sì, allora disegnamo la linea!

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

Qui usiamo la funzione Line() del Modulo Parte che crea una linea da due vettori di FreeCAD.

Tutto quanto che si crea e si modifica all'interno del modulo Parte, rimane nel modulo Parte. Quindi, fino ad ora, abbiamo creato una linea Parte. Essa non è legata ad alcun oggetto del nostro documento attivo, perciò sullo schermo non viene ancora visualizzato nulla.

shape = l.toShape()

Il documento di FreeCAD può accettare solo shape (forme) dal modulo Parte. Le shape sono il tipo più generico di forme del modulo Part. Dobbiamo quindi convertire la nostra linea in una shape prima di poterla aggiunge al documento.

Part.show(shape)

Il modulo Parte ha una funzione molto utile, show(), che crea un nuovo oggetto nel documento e collega ad esso una shape (forma).

Possiamo anche creare prima un nuovo oggetto nel documento, poi associare manualmente ad esso la shape.

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

Siccome con la nostra linea abbiamo finito, terminiamo il meccanismo di callback, che consuma preziosi cicli di CPU.

Test e Utilizzo dello script

Ora, salviamo il nostro script in qualche posizione in cui l'interprete Python di FreeCAD possa trovarlo.

Durante l'importazione dei moduli, l'interprete punta nei seguenti luoghi: i percorsi di installazione di Python, la directory bin di FreeCAD, e tutte le directory dei moduli FreeCAD. Quindi, la soluzione migliore è quella di creare una nuova directory in una delle FreeCAD Mod directories, e salvare in essa il nostro script. Per esempio, creiamo una directory "MyScripts", e salviamo il nostro script come "exercise.py".

Adesso che tutto è pronto, basta avviare FreeCAD, creare un nuovo documento, e, nell'interprete Python, eseguire:

import exercise

Se non viene visualizzato nessun messaggio di errore, significa che il nostro script "exercise" è stato caricato.

Ora possiamo controllare il suo contenuto con:

dir(exercise)

Il comando dir() è un comando integrato di Python che elenca il contenuto di un modulo. Possiamo vedere che la nostra classe line() è lì, in attesa.

Non rimane che provarla scrivendo:

exercise.line()

Poi, clicchiamo due volte nella vista 3D, e bingo, ecco la nostra linea! Per farne una nuova, basta riscrivere ancora exercise.line(), e ancora, e ancora ... Siete contenti, no?

Includere lo script nell'interfaccia di FreeCAD

Per essere davvero efficace il nostro nuovo strumento linea (line) dovrebbe avere un suo pulsante sull'interfaccia, in modo da non dover digitare ogni volta tutte queste cose.

Il modo più semplice è quello di trasformare la nostra nuova directory MyScripts in un ambiente di lavoro completo di FreeCAD.

È facile. Basta solo inserire un file chiamato InitGui.py nella directory MyScripts. Il file InitGui.py conterrà le istruzioni per creare un nuovo ambiente di lavoro (workbench), poi aggiungere ad esso il nostro nuovo strumento.

Oltre a questo dobbiamo anche modificare un po' il nostro codice di exercise, in modo che lo strumento line() sia riconosciuto come un comando ufficiale di FreeCAD.

Cominciamo creando un file InitGui.py, e scriviamo in esso il seguente codice:

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

A questo punto, penso che dovreste già capire da soli lo script precedente.

Creiamo una nuova classe che chiamiamo MyWorkbench, le diamo un titolo (MenuText), e definiamo una funzione Initialize() che verrà eseguita quando l'ambiente di lavoro verrà caricato in FreeCAD. In tale funzione, si carica il contenuto del nostro file exercise, e si aggiungono i comandi di FreeCAD contenuti in una lista di comandi.

Dopo, costruiamo una barra degli strumenti denominata "My Scripts" a cui assegniamo la nostra lista comandi. Al momento, ovviamente, disponiamo di un solo strumento, quindi la nostra lista dei comandi contiene un solo elemento.

Quando il nostro ambiente di lavoro è pronto, lo aggiungiamo all'interfaccia principale.

Questo non basta ancora perché un comando di FreeCAD deve essere formattato in un certo modo per poter funzionare. Quindi è necessario modificare un po' il nostro strumento line().

Ora il nostro nuovo script exercise.py deve essere come questo:

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())

Quì abbiamo trasformato la nostra funzione __init__() in una funzione Activated(), perchè, quando i comandi di FreeCAD vengono eseguiti, essi eseguono automaticamente la funzione Activated().

Inoltre, abbiamo aggiunto una funzione GetResources(), che fornisce a FreeCAD le informazioni per trovare l'icona dello strumento, il nome e la descrizione (tooltip) del nostro strumento.

Qualunque immagine jpg, png o svg può fungere da icona, essa può essere di qualsiasi dimensione, ma è meglio usare una dimensione vicina all'aspetto finale, come, ad esempio, 16x16, 24x24 o 32x32.

Poi, abbiamo aggiunto la classe line() come un comando ufficiale di FreeCAD con il metodo AddCommand().

Questo è tutto, ora basta riavviare FreeCAD e avremo un bell'ambiente di lavoro con il nostro nuovo strumento line()!

Cosa si può aggiungere?

Se questo esercizio vi è piaciuto, perché non cercare di migliorare questo piccolo strumento? Si possono fare molte cose, come ad esempio:

  • Aggiungere assistenza per gli utenti: fino ad ora abbiamo fatto uno strumento molto spoglio, l'utente potrebbe essere un po' disorientato quando lo utilizza. Perciò si potrebbe aggiungere qualche informazione, che suggerisca come procedere. Ad esempio, si potrebbero mostrare dei messaggi nella console di FreeCAD. In merito, visita il modulo FreeCAD.Console
  • Aggiungere la possibilità di digitare manualmente le coordinate dei punti 3D. Guarda la funzione input() di Python, per esempio
  • Aggiungere la possibilità di definire più di 2 punti
  • Aggiungere controlli per altri eventi. Al momento verifichiamo solo gli eventi del pulsante del mouse, ma se ​​vogliamo anche fare qualcosa quando il mouse viene spostato oppure visualizzare le coordinate attuali?
  • Assegnare un nome all'oggetto creato

Non esitate a scrivere le vostre domande o idee nel forum!

Arrow-left.svg Modelli di codici Pagina precedente:
Pagina successiva: Creazione di dialoghi Arrow-right.svg


Arrow-left.svg Funzione per disegnare linee Pagina precedente:
Pagina successiva: Licenza Arrow-right.svg

In questa pagina vi mostreremo come creare una semplice finestra di dialogo di Qt con Qt Designer, lo strumento ufficiale di Qt per la progettazione di interfacce, quindi come convertirla in codice Python e poi utilizzarla all'interno di FreeCAD.

Nell'esempio si assume che sappiate già come modificare ed eseguire gli script di Python, e sappiate anche fare delle cose semplici in una finestra di terminale, come navigare, ecc.

Naturalmente, è necessario che PyQt sia installato.

Progettare la finestra

Nelle applicazioni CAD, il disegno di una buona UI (interfaccia utente) è molto importante. L'utente esegue quasi tutte le operazioni tramite qualche componente dell'interfaccia: legge le finestre di dialogo, preme i pulsanti, sceglie tra le icone, ecc. Quindi è molto importante pensare attentamente a ciò che si intende fare, a come si desidera che l'utente si comporti, e a quale sarà il flusso di lavoro delle proprie azioni.

Quando si progetta l'interfaccia, è bene tenere presenti alcune cose:

  • Finestre di dialogo modali e non-modali: una finestra di dialogo modale appare sullo schermo in primo piano, blocca l'azione della finestra principale e costringe l'utente a rispondere alla finestra di dialogo, mentre un dialogo non-modale permette di continuare a lavorare sulla finestra principale. In alcuni casi è meglio usare la prima soluzione, in altri casi no.
  • Identificare ciò che è necessario e ciò che è facoltativo. Accertarsi che l'utente sappia esattamente quello che deve fare. Etichettare tutto con una descrizione adeguata, realizzare dei suggerimenti per l'uso degli strumenti, ecc.
  • Separare i comandi dei parametri. Questo solitamente si ottiene con pulsanti e campi per inserire i testi. L'utente sa che cliccando su un pulsante si produce una azione, e che, invece, sostituendo un valore all'interno di un campo di testo si modifica un parametro da qualche parte. In genere, oggi gli utenti sanno bene che cosa è un pulsante, che cosa è un campo di input, ecc. Il toolkit Qt, che stiamo per usare, è il più avanzato strumento di costruzione di interfacce. Non dovrete preoccuparvi molto di fare le cose chiare, dal momento che sarà già esso stesso molto chiaro.

Ora che abbiamo definito con precisione quello che faremo, è il momento di aprire Qt Designer.

Disegneremo una finestra di dialogo molto semplice, simile a questa:

Qttestdialog.jpg

Dopo utilizzeremo questa finestra di dialogo all'interno di FreeCAD per produrre un bel piano rettangolare. Forse pensate che produrre dei bei piani rettangolari non è particolarmente utile, però, in un secondo tempo, sarà facile apportarvi delle modifiche e creare delle cose più complesse.

Quando viene aperto, Qt Designer ha questo aspetto:

Qtdesigner-screenshot.jpg

È molto semplice da utilizzare.

Sulla barra di sinistra ci sono gli elementi che possono essere trascinati nel proprio widget (componente aggiuntivo).

Sul lato destro sono disposti i pannelli delle proprietà che mostrano tutti i tipi di proprietà modificabili degli elementi selezionati.

Per iniziare, creare un nuovo widget o complemento. Selezionare "Dialog without buttons", in quanto non vogliamo i pulsanti Ok e Annulla predefiniti. Quindi, trascinare nel proprio widget 3 labels (etichette), una per il titolo, una per inserire il testo "Altezza" e un'altra per inserire il testo "Larghezza". Le etichette sono semplici testi che appaiono nel widget, al solo scopo di informare l'utente. Quando si seleziona un'etichetta, sul lato destro appaiono diverse proprietà che volendo si possono modificare, come, ad esempio, lo stile del carattere, la sua altezza, ecc.

Poi, aggiungere 2 LineEdits, che sono campi di testo che l'utente può riempire, uno per l'altezza e uno per la larghezza. Anche di questi oggetti si possono modificare le proprietà. Ad esempio, perché non impostare un valore predefinito? Per esempio digitiamo 1,00 per ciascuno. In questo modo, quando l'utente vedrà la finestra di dialogo, entrambi i valori saranno già compilati e se gli vanno bene può premere direttamente il tasto, risparmiando tempo prezioso. Dopo, aggiungere un PushButton, che è il tasto che l'utente dovrà premere dopo aver compilato i 2 campi.

Notare che qui che ho scelto dei comandi molto semplici, ma Qt dispone di molte altre opzioni, ad esempio, è possibile utilizzare Spinboxes invece di LineEdits, ecc .. Date un'occhiata a ciò che è disponibile, vi verranno sicuramente altre idee.

Questo è tutto quello che si deve fare in Qt Designer.

Un'ultima cosa, però, rinominare tutti i propri elementi con nomi più adeguati, così negli script sarà più facile identificarli:

Qtpropeditor.jpg

Convertire il dialogo in Python

Ora, salviamo il nostro widget da qualche parte. Esso verrà salvato come un file .ui, che potremo facilmente convertire in script di Python tramite pyuic. Su Windows, il programma pyuic è incluso con PyQt (da verificare), su Linux probabilmente è necessario installarlo separatamente tramite il proprio gestore di pacchetti (su sistemi debian-based è parte del pacchetto di strumenti PyQt4-dev-tools). Per fare la conversione, è necessario aprire una finestra di terminale (o una finestra del prompt dei comandi in Windows), portarsi nella cartella in cui si è salvato il file .ui, e digitare:

pyuic mywidget.ui > mywidget.py

In Windows pyuic.py si trova in "C:\Python27\Lib\site-packages\PyQt4\uic\pyuic.py" Per creare il file batch "compQt4.bat:

@"C:\Python27\python" "C:\Python27\Lib\site-packages\PyQt4\uic\pyuic.py" -x %1.ui > %1.py

Nella console Dos digitare senza estensione

compQt4 myUiFile

In Linux : da fare

Dato che, dopo la versione 0.13, FreeCAD si è progressivamente allontanato da PyQt a favore di PySide (Choice your PySide install building PySide), per costruire il file basato su PySide ora è necessario utilizzare:

pyside-uic mywidget.ui -o mywidget.py

In Windows uic.py si trova in "C:\Python27\Lib\site-packages\PySide\scripts\uic.py" Per creare il file batch "compSide.bat":

@"C:\Python27\python" "C:\Python27\Lib\site-packages\PySide\scripts\uic.py" %1.ui > %1.py

Nella console Dos digitare senza estensione

compSide myUiFile

In Linux : da fare

Su alcuni sistemi il programma si chiama pyuic4 invece di pyuic. Questa operazione converte semplicemente il file .ui in uno script Python. Se apriamo il file mywidget.py, è molto facile capire il suo contenuto:

from PySide 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))
        ...

Come potete vedere ha una struttura molto semplice: viene creata una classe denominata Ui_Dialog, che memorizza gli elementi dell'interfaccia del nostro widget. Questa classe ha due metodi, uno per la creazione del widget, e uno per la traduzione del suo contenuto, questo fa parte del meccanismo generale di Qt per tradurre gli elementi dell'interfaccia. Il metodo di installazione crea semplicemente, uno per uno, i widget come li abbiamo definiti in Qt Designer, e imposta le loro opzioni come abbiamo deciso in precedenza. Poi, viene tradotta l'intera interfaccia e, infine, vengono collegati gli slot (di cui parleremo più avanti).

Ora possiamo creare un nuovo widget, e utilizzare questa classe per creare la sua interfaccia. A questo punto, possiamo già vedere in azione il nostro widget e, per provarlo, mettiamo il nostro file mywidget.py in un luogo dove FreeCAD possa trovarlo (nella directory bin di FreeCAD, o in una qualsiasi delle sottodirectory Mod), e, nell'interprete Python di FreeCAD, digitiamo:

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

Ecco apparire la nostra finestra di dialogo! Notare che il nostro interprete Python sta ancora funzionando in quanto stiamo usando un dialogo non-modale. Per chiudere la finestra, (ovviamente, oltre a cliccare sulla sua icona di chiusura) possiamo digitare:

d.hide()

Ora che siamo in grado di mostrare e nascondere la nostra finestra di dialogo, basta solo aggiungere una ultima parte: per fargli fare qualcosa!

Provando per un po' Qt Designer, scoprirete presto un'intera sezione chiamata "signals and slots" (segnali e porte di ingresso dei segnali).

In pratica, funziona così: i componenti dei widget (nella terminologia Qt, questi elementi sono a loro volta dei widget) sono in grado di inviare dei segnali. Tali segnali differiscono a seconda del tipo widget. Ad esempio, un pulsante può inviare un segnale quando viene premuto e quando viene rilasciato. Questi segnali possono essere collegati agli slot. Gli slot possono essere una funzionalità speciale di altri widget (ad esempio una finestra di dialogo ha uno slot "close" al quale è possibile collegare il segnale di un pulsante di chiusura), o possono essere funzioni personalizzate.

La Documentazione di riferimento di PyQt elenca tutti i widget Qt, che cosa possono fare, quali segnali possono inviare, ecc..

Qui, come esempio, creiamo una nuova funzione che genera un piano basato su altezza e larghezza, e colleghiamo tale funzione al segnale "pressed" (premuto) emesso dal pulsante "Create!".

Allora, cominciamo con l'importazione dei nostri moduli FreeCAD, inserendo la seguente riga all'inizio dello script, dove importiamo già QtCore e QtGui:

import FreeCAD, Part

Dopo, aggiungiamo una nuova funzione alla nostra classe 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()

Poi, bisogna dire a Qt di collegare il pulsante alla funzione, inserendo la seguente riga appena prima di QtCore.QMetaObject.connectSlotsByName (Dialog):

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

Questo, come vedete, collega il segnale "pressed()" del nostro oggetto create (il pulsante "Create!"), allo slot chiamato createPlane, che abbiamo appena definito. Questo è tutto!

Ora, come tocco finale, possiamo aggiungere una piccola funzione per creare il dialogo, così sarà più facile chiamarlo.

Fuori dalla classe Ui_Dialog, aggiungiamo questo codice:

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

(Promemoria di Python: ogni volta che viene creato un nuovo oggetto il metodo __init__ di una classe viene eseguito automaticamente!)

Poi, da FreeCAD, basta solo fare:

import mywidget
myDialog = mywidget.plane()

Questo è tutto amici ... Ora è possibile provare diverse cose, come ad esempio inserire il widget nell'interfaccia di FreeCAD (vedere la pagina Esempi di codici), oppure creare strumenti personalizzati molto più avanzati, utilizzando altri elementi nel proprio widget.

Lo script completo

Questo è lo script completo di riferimento:

# -*- 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
# Modified for PySide 16:02:2015 
# WARNING! All changes made in this file will be lost!

from PySide 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():
   def __init__(self):
       self.d = QtGui.QWidget()
       self.ui = Ui_Dialog()
       self.ui.setupUi(self.d)
       self.d.show()

Creare una finestra di dialogo con i pulsanti

Metodo 1

Esempio di una finestra di dialogo completa con le sue connessioni.

# -*- coding: utf-8 -*-
# Create by flachyjoe

from PySide import QtCore, QtGui

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
        return s

try:
    _encoding = QtGui.QApplication.UnicodeUTF8
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig)


class Ui_MainWindow(object):

     def __init__(self, MainWindow):
        self.window = MainWindow

        MainWindow.setObjectName(_fromUtf8("MainWindow"))
        MainWindow.resize(400, 300)
        self.centralWidget = QtGui.QWidget(MainWindow)
        self.centralWidget.setObjectName(_fromUtf8("centralWidget"))

        self.pushButton = QtGui.QPushButton(self.centralWidget)
        self.pushButton.setGeometry(QtCore.QRect(30, 170, 93, 28))
        self.pushButton.setObjectName(_fromUtf8("pushButton"))
        self.pushButton.clicked.connect(self.on_pushButton_clicked) #connection pushButton

        self.lineEdit = QtGui.QLineEdit(self.centralWidget)
        self.lineEdit.setGeometry(QtCore.QRect(30, 40, 211, 22))
        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
        self.lineEdit.returnPressed.connect(self.on_lineEdit_clicked) #connection lineEdit

        self.checkBox = QtGui.QCheckBox(self.centralWidget)
        self.checkBox.setGeometry(QtCore.QRect(30, 90, 81, 20))
        self.checkBox.setChecked(True)
        self.checkBox.setObjectName(_fromUtf8("checkBoxON"))
        self.checkBox.clicked.connect(self.on_checkBox_clicked) #connection checkBox

        self.radioButton = QtGui.QRadioButton(self.centralWidget)
        self.radioButton.setGeometry(QtCore.QRect(30, 130, 95, 20))
        self.radioButton.setObjectName(_fromUtf8("radioButton"))
        self.radioButton.clicked.connect(self.on_radioButton_clicked) #connection radioButton

        MainWindow.setCentralWidget(self.centralWidget)

        self.menuBar = QtGui.QMenuBar(MainWindow)
        self.menuBar.setGeometry(QtCore.QRect(0, 0, 400, 26))
        self.menuBar.setObjectName(_fromUtf8("menuBar"))
        MainWindow.setMenuBar(self.menuBar)

        self.mainToolBar = QtGui.QToolBar(MainWindow)
        self.mainToolBar.setObjectName(_fromUtf8("mainToolBar"))
        MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar)

        self.statusBar = QtGui.QStatusBar(MainWindow)
        self.statusBar.setObjectName(_fromUtf8("statusBar"))
        MainWindow.setStatusBar(self.statusBar)

        self.retranslateUi(MainWindow)

     def retranslateUi(self, MainWindow):
        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None))
        self.pushButton.setText(_translate("MainWindow", "OK", None))
        self.lineEdit.setText(_translate("MainWindow", "tyty", None))
        self.checkBox.setText(_translate("MainWindow", "CheckBox", None))
        self.radioButton.setText(_translate("MainWindow", "RadioButton", None))

     def on_checkBox_clicked(self):
        if self.checkBox.checkState()==0:
            App.Console.PrintMessage(str(self.checkBox.checkState())+"  CheckBox KO\r\n")
        else:     
            App.Console.PrintMessage(str(self.checkBox.checkState())+" CheckBox OK\r\n")
#        App.Console.PrintMessage(str(self.lineEdit.setText("tititi"))+" LineEdit\r\n") #write text to the lineEdit window !
#        str(self.lineEdit.setText("tititi")) #écrit le texte dans la fenêtre lineEdit
        App.Console.PrintMessage(str(self.lineEdit.displayText())+" LineEdit\r\n")

     def on_radioButton_clicked(self):
        if self.radioButton.isChecked():
             App.Console.PrintMessage(str(self.radioButton.isChecked())+" Radio OK\r\n")
        else:
             App.Console.PrintMessage(str(self.radioButton.isChecked())+"  Radio KO\r\n")

     def on_lineEdit_clicked(self):
#        if self.lineEdit.textChanged():
             App.Console.PrintMessage(str(self.lineEdit.displayText())+" LineEdit Display\r\n")

     def on_pushButton_clicked(self):
        App.Console.PrintMessage("Terminé\r\n")
        self.window.hide()

MainWindow = QtGui.QMainWindow()
ui = Ui_MainWindow(MainWindow)
MainWindow.show()

Ecco la stessa finestra, ma con una icona per ogni pulsante.

Scaricare le icone associate (Clic destro "Salva immagine con nome")

Icone01.png Icone02.png Icone03.png

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

from PySide import QtCore, QtGui

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
        return s

try:
    _encoding = QtGui.QApplication.UnicodeUTF8
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig)


class Ui_MainWindow(object):

     def __init__(self, MainWindow):
        self.window = MainWindow
        path = FreeCAD.ConfigGet("UserAppData")
#        path = FreeCAD.ConfigGet("AppHomePath")

        MainWindow.setObjectName(_fromUtf8("MainWindow"))
        MainWindow.resize(400, 300)
        self.centralWidget = QtGui.QWidget(MainWindow)
        self.centralWidget.setObjectName(_fromUtf8("centralWidget"))

        self.pushButton = QtGui.QPushButton(self.centralWidget)
        self.pushButton.setGeometry(QtCore.QRect(30, 170, 93, 28))
        self.pushButton.setObjectName(_fromUtf8("pushButton"))
        self.pushButton.clicked.connect(self.on_pushButton_clicked) #connection pushButton

        self.lineEdit = QtGui.QLineEdit(self.centralWidget)
        self.lineEdit.setGeometry(QtCore.QRect(30, 40, 211, 22))
        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
        self.lineEdit.returnPressed.connect(self.on_lineEdit_clicked) #connection lineEdit

        self.checkBox = QtGui.QCheckBox(self.centralWidget)
        self.checkBox.setGeometry(QtCore.QRect(30, 90, 100, 20))
        self.checkBox.setChecked(True)
        self.checkBox.setObjectName(_fromUtf8("checkBoxON"))
        self.checkBox.clicked.connect(self.on_checkBox_clicked) #connection checkBox

        self.radioButton = QtGui.QRadioButton(self.centralWidget)
        self.radioButton.setGeometry(QtCore.QRect(30, 130, 95, 20))
        self.radioButton.setObjectName(_fromUtf8("radioButton"))
        self.radioButton.clicked.connect(self.on_radioButton_clicked) #connection radioButton

        MainWindow.setCentralWidget(self.centralWidget)

        self.menuBar = QtGui.QMenuBar(MainWindow)
        self.menuBar.setGeometry(QtCore.QRect(0, 0, 400, 26))
        self.menuBar.setObjectName(_fromUtf8("menuBar"))
        MainWindow.setMenuBar(self.menuBar)

        self.mainToolBar = QtGui.QToolBar(MainWindow)
        self.mainToolBar.setObjectName(_fromUtf8("mainToolBar"))
        MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar)

        self.statusBar = QtGui.QStatusBar(MainWindow)
        self.statusBar.setObjectName(_fromUtf8("statusBar"))
        MainWindow.setStatusBar(self.statusBar)

        self.retranslateUi(MainWindow)

        # Affiche un icone sur le bouton PushButton
        # self.image_01 = "C:\Program Files\FreeCAD0.13\Icone01.png" # adapt the icon name
        self.image_01 = path+"Icone01.png" # adapt the name of the icon
        icon01 = QtGui.QIcon() 
        icon01.addPixmap(QtGui.QPixmap(self.image_01),QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.pushButton.setIcon(icon01) 
        self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button

        # Affiche un icone sur le bouton RadioButton 
        # self.image_02 = "C:\Program Files\FreeCAD0.13\Icone02.png" # adapt the name of the icon
        self.image_02 = path+"Icone02.png" # adapter le nom de l'icone
        icon02 = QtGui.QIcon() 
        icon02.addPixmap(QtGui.QPixmap(self.image_02),QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.radioButton.setIcon(icon02) 
        # self.radioButton.setLayoutDirection(QtCore.Qt.RightToLeft) #  This command reverses the direction of the button

        # Affiche un icone sur le bouton CheckBox 
        # self.image_03 = "C:\Program Files\FreeCAD0.13\Icone03.png" # the name of the icon
        self.image_03 = path+"Icone03.png" # adapter le nom de l'icone
        icon03 = QtGui.QIcon() 
        icon03.addPixmap(QtGui.QPixmap(self.image_03),QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.checkBox.setIcon(icon03) 
        # self.checkBox.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button


     def retranslateUi(self, MainWindow):
        MainWindow.setWindowTitle(_translate("MainWindow", "FreeCAD", None))
        self.pushButton.setText(_translate("MainWindow", "OK", None))
        self.lineEdit.setText(_translate("MainWindow", "tyty", None))
        self.checkBox.setText(_translate("MainWindow", "CheckBox", None))
        self.radioButton.setText(_translate("MainWindow", "RadioButton", None))

     def on_checkBox_clicked(self):
        if self.checkBox.checkState()==0:
            App.Console.PrintMessage(str(self.checkBox.checkState())+"  CheckBox KO\r\n")
        else:     
            App.Console.PrintMessage(str(self.checkBox.checkState())+" CheckBox OK\r\n")
           # App.Console.PrintMessage(str(self.lineEdit.setText("tititi"))+" LineEdit\r\n") # write text to the lineEdit window !
           # str(self.lineEdit.setText("tititi")) #écrit le texte dans la fenêtre lineEdit
        App.Console.PrintMessage(str(self.lineEdit.displayText())+" LineEdit\r\n")

     def on_radioButton_clicked(self):
        if self.radioButton.isChecked():
             App.Console.PrintMessage(str(self.radioButton.isChecked())+" Radio OK\r\n")
        else:
             App.Console.PrintMessage(str(self.radioButton.isChecked())+"  Radio KO\r\n")

     def on_lineEdit_clicked(self):
          # if self.lineEdit.textChanged():
          App.Console.PrintMessage(str(self.lineEdit.displayText())+" LineEdit Display\r\n")

     def on_pushButton_clicked(self):
        App.Console.PrintMessage("Terminé\r\n")
        self.window.hide()

MainWindow = QtGui.QMainWindow()
ui = Ui_MainWindow(MainWindow)
MainWindow.show()

Ecco il codice per visualizzare l'icona sul pushButton, cambiare il nome di un altro pulsante, (radioButton, checkBox) e il percorso per l'icona.

# Affiche un icône sur le bouton PushButton
        # self.image_01 = "C:\Program Files\FreeCAD0.13\icone01.png" # the name of the icon
        self.image_01 = path+"icone01.png" # the name of the icon
        icon01 = QtGui.QIcon() 
        icon01.addPixmap(QtGui.QPixmap(self.image_01),QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.pushButton.setIcon(icon01) 
        self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button

Il comando UserAppData dà il percorso dell'utente AppHomePath dà il percorso di installazione di FreeCAD

#        path = FreeCAD.ConfigGet("UserAppData")
        path = FreeCAD.ConfigGet("AppHomePath")

Questo comando inverte il pulsante orizzontale, da destra a sinistra.

self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button

Metodo 2

Un altro metodo per visualizzare una finestra. In questo caso creando un file QtForm.py che contiene il programma di intestazione (modulo chiamato con import QtForm), e un secondo modulo che contiene il codice della finestra di tutti questi accessori e il vostro codice (il modulo di chiamata).

Questo metodo richiede due file separati, ma permette di accorciare il programma utilizzando il file QtForm.py con import. Poi distribuire insieme i due file, essi sono inseparabili.

Il file QtForm.py

# -*- coding: utf-8 -*-
# Create by flachyjoe
from PySide import QtCore, QtGui

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
   def _fromUtf8(s):
      return s

try:
    _encoding = QtGui.QApplication.UnicodeUTF8
    def _translate(context, text, disambig):
      return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
   def _translate(context, text, disambig):
      return QtGui.QApplication.translate(context, text, disambig)

class Form(object):
   def __init__(self, title, width, height):
      self.window = QtGui.QMainWindow()
      self.title=title
      self.window.setObjectName(_fromUtf8(title))
      self.window.setWindowTitle(_translate(self.title, self.title, None))
      self.window.resize(width, height)

   def show(self):
      self.createUI()
      self.retranslateUI()
      self.window.show()
   
   def setText(self, control, text):
      control.setText(_translate(self.title, text, None))

L'appellante, il file che contiene la finestra e il tuo codice

Il file my_file.py

I collegamenti sono da fare, sono un buon esercizio.

# -*- coding: utf-8 -*-
# Create by flachyjoe
from PySide import QtCore, QtGui
import QtForm

class myForm(QtForm.Form):
   def createUI(self):
      self.centralWidget = QtGui.QWidget(self.window)
      self.window.setCentralWidget(self.centralWidget)
      
      self.pushButton = QtGui.QPushButton(self.centralWidget)
      self.pushButton.setGeometry(QtCore.QRect(30, 170, 93, 28))
      self.pushButton.clicked.connect(self.on_pushButton_clicked)
      
      self.lineEdit = QtGui.QLineEdit(self.centralWidget)
      self.lineEdit.setGeometry(QtCore.QRect(30, 40, 211, 22))
      
      self.checkBox = QtGui.QCheckBox(self.centralWidget)
      self.checkBox.setGeometry(QtCore.QRect(30, 90, 81, 20))
      self.checkBox.setChecked(True)
      
      self.radioButton = QtGui.QRadioButton(self.centralWidget)
      self.radioButton.setGeometry(QtCore.QRect(30, 130, 95, 20))
   
   def retranslateUI(self):
      self.setText(self.pushButton, "Fermer")
      self.setText(self.lineEdit, "essais de texte")
      self.setText(self.checkBox, "CheckBox")
      self.setText(self.radioButton, "RadioButton")
   
   def on_pushButton_clicked(self):
      self.window.hide()

myWindow=myForm("Fenetre de test",400,300)
myWindow.show()

Altro esempio


Sono trattati:

  1. Icona per la finestra
  2. Cursore orizzontale
  3. Barra di progressione orizzontale
  4. Cursore verticale
  5. Barra di progressione verticale
  6. Riga editabile
  7. Riga editabile
  8. Casella di selezione bidirezionale
  9. Casella di selezione bidirezionale
  10. Casella di selezione bidirezionale
  11. Pulsante
  12. Pulsante
  13. Pulsante di opzione con icona
  14. Casella di controllo con l'icona di attivazione e disattivazione
  15. Campo editabile con un testo
  16. Campo di vista grafica con 2 grafici

La pagina del codice e delle icone: Qt_Example

Icone personalizzate nella Vista combinata

Questo esempio crea oggetti con proprietà e icona personalizzate in ComboView

Scaricare l'icona di esempio e posizionarla nella stessa directory della macro icon Example for the macro

Vengono elaborati tre metodi per assegnare un'icona a un oggetto, un'icona in formato .png presente in un file sul disco, un'icona salvata in formato .xpm inclusa nella macro stessa e un'icona disponibile nelle risorse di FreeCAD.

icon personalised


import PySide
import FreeCAD, FreeCADGui, Part
from pivy import coin
from PySide import QtGui ,QtCore
from PySide.QtGui import *
from PySide.QtCore import *
import Draft

global path
param = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Macro")# macro path in FreeCAD preferences
path = param.GetString("MacroPath","") + "/"                        # macro path
path = path.replace("\\","/")                                       # convert the "\" to "/"


class IconViewProviderToFile:                                       # Class ViewProvider create Property view of object
    def __init__( self, obj, icon):
        self.icone = icon
        
    def getIcon(self):                                              # GetIcon
        return self.icone
        
    def attach(self, obj):                                          # Property view of object
        self.modes = []
        self.modes.append("Flat Lines")
        self.modes.append("Shaded")
        self.modes.append("Wireframe")
        self.modes.append("Points")
        obj.addDisplayMode( coin.SoGroup(),"Flat Lines" )           # Display Mode
        obj.addDisplayMode( coin.SoGroup(),"Shaded" )
        obj.addDisplayMode( coin.SoGroup(),"Wireframe" )
        obj.addDisplayMode( coin.SoGroup(),"Points" )
        return self.modes

    def getDisplayModes(self,obj):
        return self.modes

#####################################################
########## Example with icon to file # begin ########
#####################################################

object1 = FreeCAD.ActiveDocument.addObject("App::FeaturePython", "Icon_In_File_Disk")                                     # create your object
object1.addProperty("App::PropertyString","Identity", "ExampleTitle0", "Identity of object").Identity = "FCSpring"        # Identity of object
object1.addProperty("App::PropertyFloat" ,"Pitch",    "ExampleTitle0", "Pitch betwen 2 heads").Pitch  = 2.0               # other Property Data
object1.addProperty("App::PropertyBool"  ,"View",     "ExampleTitle1", "Hello world").View            = True              # ...
object1.addProperty("App::PropertyColor" ,"LineColor","ExampleTitle2", "Color to choice").LineColor   = (0.13,0.15,0.37)  # ...
#...other Property Data
#...other Property Data
#
object1.ViewObject.Proxy = IconViewProviderToFile( object1, path + "FreeCADIco.png")                                      # icon download to file
App.ActiveDocument.recompute()
#
#__Detail__:
# FreeCAD.ActiveDocument.addObject( = create now object personalized
# "App::FeaturePython",             = object as FeaturePython
# "Icon_In_File_Disk")              = internal name of your object
#
#
# "App::PropertyString",    = type of Property , availlable : PropertyString, PropertyFloat, PropertyBool, PropertyColor
# "Identity",               = name of the feature
# "ExampleTitle0",          = title of the "section"
# "Identity of object")     = tooltip displayed on mouse
# .Identity                 = variable (same of name of the feature)
# object1.ViewObject.Proxy  = create the view object and gives the icon
#
########## example with icon to file end



#####################################################
########## Example with icon in macro # begin #######
#####################################################

def setIconInMacro(self):        # def contener the icon in format .xpm
    # File format XPM created by Gimp "https://www.gimp.org/"
    # Choice palette Tango
    # Create your masterwork ...
    # For export the image in XPM format
    #     Menu File > Export as > .xpm
    # (For convert image true color in Tango color palette : 
    #     Menu Image > Mode > Indexed ... > Use custom palette > Tango Icon Theme > Convert)
    return """
            /* XPM */
            static char * XPM[] = {
            "22 24 5 1",
            " 	c None",
            ".	c #CE5C00",
            "+	c #EDD400",
            "@	c #F57900",
            "#	c #8F5902",
            "                      ",
            "                      ",
            "  ....                ",
            "  ..@@@@..            ",
            "  . ...@......        ",
            "  .+++++++++...       ",
            "  .      ....++...    ",
            "  .@..@@@@@@.+++++..  ",
            "  .@@@@@..#  ++++ ..  ",
            "  .       ++++  .@..  ",
            "  .++++++++  .@@@.+.  ",
            " .      ..@@@@@. ++.  ",
            " ..@@@@@@@@@.  +++ .  ",
            " ....@...# +++++ @..  ",
            " .    ++++++++ .@. .  ",
            " .++++++++  .@@@@ .   ",
            " .   #....@@@@. ++.   ",
            " .@@@@@@@@@.. +++ .   ",
            " ........  +++++...   ",
            " ...  ..+++++ ..@..   ",
            "    ......  .@@@ +.   ",
            "          ......++.   ",
            "                ...   ",
            "                      "};
        """

object2 = FreeCAD.ActiveDocument.addObject("App::FeaturePython", "Icon_XPM_In_Macro")                                    #
object2.addProperty("App::PropertyString","Identity","ExampleTitle","Identity of object").Identity = "FCSpring"
#...other Property Data
#...other Property Data
#
object2.ViewObject.Proxy = IconViewProviderToFile( object2, setIconInMacro(""))              # icon in macro (.XPM)
App.ActiveDocument.recompute()
########## example with icon in macro end



####################################################################
########## Example with icon to FreeCAD ressource # begin ##########
####################################################################

object3 = FreeCAD.ActiveDocument.addObject("App::FeaturePython", "Icon_Ressource_FreeCAD")                               #
object3.addProperty("App::PropertyString","Identity","ExampleTitle","Identity of object").Identity = "FCSpring"
#...other Property Data
#...other Property Data
#
object3.ViewObject.Proxy = IconViewProviderToFile( object3, ":/icons/Draft_Draft.svg")       # icon to FreeCAD ressource
App.ActiveDocument.recompute()
########## example with icon to FreeCAD ressource end

Altro esempio completo di creazione di un cubo con l'icona nella macro

#https://forum.freecadweb.org/viewtopic.php?t=10255#p83319
import FreeCAD, Part, math
from FreeCAD import Base
from PySide import QtGui

global path
param = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Macro")# macro path in FreeCAD preferences
path = param.GetString("MacroPath","") + "/"                        # macro path
path = path.replace("\\","/")                                       # convert the "\" to "/"

def setIconInMacro(self):
    return """
        /* XPM */
        static char * xpm[] = {
        "22 22 12 1",
        " 	c None",
        ".	c #A40000",
        "+	c #2E3436",
        "@	c #CE5C00",
        "#	c #F57900",
        "$	c #FCAF3E",
        "%	c #5C3566",
        "&	c #204A87",
        "*	c #555753",
        "=	c #3465A4",
        "-	c #4E9A06",
        ";	c #729FCF",
        "                      ",
        "                      ",
        "                      ",
        "        ..   ..       ",
        "       +@#+++.$$      ",
        "       +.#+%..$$      ",
        "       &*$  &*#*      ",
        "      &   =&=  =      ",
        "   ++&  +.==   %=     ",
        "  ++$@ ..$ %=   &     ",
        "  ..-&%.#$$ &## +=$   ",
        "   .#  ..$ ..#%%.#$$  ",
        "     ;    =+=## %-$#  ",
        "     &=   ;&   %=     ",
        "      ;+ &=;  %=      ",
        "      ++$- +*$-       ",
        "      .#&&+.@$$       ",
        "      ..$# ..$#       ",
        "       ..   ..        ",
        "                      ",
        "                      ",
        "                      "};
        """

class PartFeature:
    def __init__(self, obj):
        obj.Proxy = self

class Box(PartFeature):
    def __init__(self, obj):
        PartFeature.__init__(self, obj)
        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

    def onChanged(self, fp, prop):
        try:
            if prop == "Length" or prop == "Width" or prop == "Height":
                fp.Shape = Part.makeBox(fp.Length,fp.Width,fp.Height)
        except:
            pass

    def execute(self, fp):
        fp.Shape = Part.makeBox(fp.Length,fp.Width,fp.Height)

class ViewProviderBox:
    def __init__(self, obj, icon):
        obj.Proxy  = self
        self.icone = icon
        
    def getIcon(self):
        return self.icone

    def attach(self, obj):
        return

    def setupContextMenu(self, obj, menu):
        action = menu.addAction("Set default height")
        action.triggered.connect(lambda f=self.setDefaultHeight, arg=obj:f(arg))

        action = menu.addAction("Hello World")
        action.triggered.connect(self.showHelloWorld)

    def setDefaultHeight(self, view):
        view.Object.Height = 15.0

    def showHelloWorld(self):
        QtGui.QMessageBox.information(None, "Hi there", "Hello World")

def makeBox():
    FreeCAD.newDocument()
    a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","Box")
    Box(a)
#    ViewProviderBox(a.ViewObject, path + "FreeCADIco.png")    # icon download to file
#    ViewProviderBox(a.ViewObject,  ":/icons/Draft_Draft.svg") # icon to FreeCAD ressource
    ViewProviderBox(a.ViewObject,  setIconInMacro(""))        # icon in macro (.XPM)
    App.ActiveDocument.recompute()

makeBox()

Scrivere il file con QFileDialog

Codice completo:

# -*- coding: utf-8 -*-
import PySide
from PySide import QtGui ,QtCore
from PySide.QtGui import *
from PySide.QtCore import *
path = FreeCAD.ConfigGet("UserAppData")

try:
    SaveName = QFileDialog.getSaveFileName(None,QString.fromLocal8Bit("Save a file txt"),path,             "*.txt") # PyQt4
#                                                                     "here the text displayed on windows" "here the filter (extension)"   
except Exception:
    SaveName, Filter = PySide.QtGui.QFileDialog.getSaveFileName(None, "Save a file txt", path,             "*.txt") # PySide
#                                                                     "here the text displayed on windows" "here the filter (extension)"   
if SaveName == "":                                                            # if the name file are not selected then Abord process
    App.Console.PrintMessage("Process aborted"+"\n")
else:                                                                         # if the name file are selected or created then 
    App.Console.PrintMessage("Registration of "+SaveName+"\n")                # text displayed to Report view (Menu > View > Report view checked)
    try:                                                                      # detect error ...
        file = open(SaveName, 'w')                                            # open the file selected to write (w)
        try:                                                                  # if error detected to write ...
            # here your code
            print("here your code")
            file.write(str(1)+"\n")                                           # write the number convert in text with (str())
            file.write("FreeCAD the best")                                    # write the the text with ("  ")
        except Exception:                                                     # if error detected to write
            App.Console.PrintError("Error write file "+"\n")                  # detect error ... display the text in red (PrintError)
        finally:                                                              # if error detected to write ... or not the file is closed
            file.close()                                                      # if error detected to write ... or not the file is closed
    except Exception:
        App.Console.PrintError("Error Open file "+SaveName+"\n")      # detect error ... display the text in red (PrintError)

Leggere il file con QFileDialog

Codice completo:

# -*- coding: utf-8 -*-
import PySide
from PySide import QtGui ,QtCore
from PySide.QtGui import *
from PySide.QtCore import *
path = FreeCAD.ConfigGet("UserAppData")

OpenName = ""
try:
    OpenName = QFileDialog.getOpenFileName(None,QString.fromLocal8Bit("Read a file txt"),path,             "*.txt") # PyQt4
#                                                                     "here the text displayed on windows" "here the filter (extension)"   
except Exception:
    OpenName, Filter = PySide.QtGui.QFileDialog.getOpenFileName(None, "Read a file txt", path,             "*.txt") #PySide
#                                                                     "here the text displayed on windows" "here the filter (extension)"   
if OpenName == "":                                                            # if the name file are not selected then Abord process
    App.Console.PrintMessage("Process aborted"+"\n")
else:
    App.Console.PrintMessage("Read "+OpenName+"\n")                           # text displayed to Report view (Menu > View > Report view checked)
    try:                                                                      # detect error to read file
        file = open(OpenName, "r")                                            # open the file selected to read (r)  # (rb is binary)
        try:                                                                  # detect error ...
            # here your code
            print("here your code")
            op = OpenName.split("/")                                          # decode the path
            op2 = op[-1].split(".")                                           # decode the file name 
            nomF = op2[0]                                                     # the file name are isolated

            App.Console.PrintMessage(str(nomF)+"\n")                          # the file name are displayed

            for ligne in file:                                                # read the file
                X  = ligne.rstrip('\n\r') #.split()                           # decode the line
                print(X)                                                      # print the line in report view other method 
                                                                              # (Menu > Edit > preferences... > Output window > Redirect internal Python output (and errors) to report view checked) 
        except Exception:                                                     # if error detected to read
            App.Console.PrintError("Error read file "+"\n")                   # detect error ... display the text in red (PrintError)
        finally:                                                              # if error detected to read ... or not error the file is closed
            file.close()                                                      # if error detected to read ... or not error the file is closed
    except Exception:                                                         # if one error detected to read file
        App.Console.PrintError("Error in Open the file "+OpenName+"\n")       # if one error detected ... display the text in red (PrintError)

Ottenere i colori con QColorDialog

Codice completo:

# -*- coding: utf-8 -*-
# https://deptinfo-ensip.univ-poitiers.fr/ENS/pyside-docs/PySide/QtGui/QColor.html
import PySide
from PySide import QtGui ,QtCore
from PySide.QtGui import *
from PySide.QtCore import *
path = FreeCAD.ConfigGet("UserAppData")

couleur = QtGui.QColorDialog.getColor()
if couleur.isValid():
    red   = int(str(couleur.name()[1:3]),16)    # decode hexadecimal to int()
    green = int(str(couleur.name()[3:5]),16)    # decode hexadecimal to int()
    blue  = int(str(couleur.name()[5:7]),16)    # decode hexadecimal to int()

    print(couleur)                              # 
    print("hexadecimal ",couleur.name())        # color format hexadecimal mode 16
    print("Red   color ",red)                   # color format decimal
    print("Green color ",green)                 # color format decimal
    print("Blue  color ",blue)                  # color format decimal

Ottenere i colori con QColorDialog e creare la vostra paletta di colori (Standard e Personalizzate)

Questo esempio modifica il colore Standard e il colore Personalizza seguendo la guida di Tango FreeCAD.

Codice completo:


# -*- coding: utf-8 -*-
# https://deptinfo-ensip.univ-poitiers.fr/ENS/pyside-docs/PySide/QtGui/QColor.html
import PySide
from PySide import QtGui ,QtCore
from PySide.QtGui import *
from PySide.QtCore import *

###############################################
##        Window colors organisation         ##
##        __________________________         ##
## StandardColor:                            ##
##                                           ##
##           Colonnes:                       ##
##           1:  2:  3:  4:  5:  6:  7:  8:  ##
##          _______________________________  ##
## Line 1:   0   6   12  18  24  30  36  42  ##
## Line 2:   1   7   13  19  25  31  37  43  ##
## Line 3:   2   8   14  20  26  32  38  44  ##
## Line 4:   3   9   15  21  27  33  39  45  ##
## Line 5:   4   10  16  22  28  34  40  46  ##
## Line 6:   5   11  17  23  29  35  41  47  ##
##                                           ##
## CustomColor:                              ##
##                                           ##
##           Colonnes:                       ##
##           1:  2:  3:  4:  5:  6:  7:  8:  ##
##          _______________________________  ##
## Line 1:   0   2   4   6   8   10  12  14  ##
## Line 2:   1   3   5   7   9   11  13  15  ##
##                                           ##
###############################################

color_Dialog   = QtGui.QColorDialog()
# FreeCAD-Tango
# Customize the colors in the standard box (in numeric mode)
#
#### Dialog line 1
color_Dialog.setStandardColor( 0, QtGui.QColor(252, 233,  79 , 0).rgba())    # Butte 1
color_Dialog.setStandardColor( 6, QtGui.QColor(237, 212,   0 , 0).rgba())    # Butte 2
color_Dialog.setStandardColor(12, QtGui.QColor(196, 160,   0 , 0).rgba())    # Butte 3
color_Dialog.setStandardColor(18, QtGui.QColor( 48,  43,   0 , 0).rgba())    # Butte 4

color_Dialog.setStandardColor(24, QtGui.QColor(138, 226,  52 , 0).rgba())    # Chameleo 1
color_Dialog.setStandardColor(30, QtGui.QColor(115, 210,  22 , 0).rgba())    # Chameleo 2
color_Dialog.setStandardColor(36, QtGui.QColor( 78, 154,   6 , 0).rgba())    # Chameleo 3
color_Dialog.setStandardColor(42, QtGui.QColor( 23,  42,   4 , 0).rgba())    # Chameleo 4
#### Dialog line 2
color_Dialog.setStandardColor( 1, QtGui.QColor(252, 175,  62 , 0).rgba())    # Orang 1
color_Dialog.setStandardColor( 7, QtGui.QColor(245, 121,   0 , 0).rgba())    # Orang 2
color_Dialog.setStandardColor(13, QtGui.QColor(206,  92,   0 , 0).rgba())    # Orang 3
color_Dialog.setStandardColor(19, QtGui.QColor( 50,  25,   0 , 0).rgba())    # Orang 4

color_Dialog.setStandardColor(25, QtGui.QColor(114, 159, 207 , 0).rgba())    # Sky Blu 1
color_Dialog.setStandardColor(31, QtGui.QColor( 52, 101, 164 , 0).rgba())    # Sky Blu 2
color_Dialog.setStandardColor(37, QtGui.QColor( 32,  74, 135 , 0).rgba())    # Sky Blu 3
color_Dialog.setStandardColor(43, QtGui.QColor( 11,  21,  33 , 0).rgba())    # Sky Blu 4
#### Dialog line 3
color_Dialog.setStandardColor( 2, QtGui.QColor(173, 127, 168 , 0).rgba())    # Plu 1
color_Dialog.setStandardColor( 8, QtGui.QColor(117,  80, 123 , 0).rgba())    # Plu 2
color_Dialog.setStandardColor(14, QtGui.QColor( 92,  53, 102 , 0).rgba())    # Plu 3
color_Dialog.setStandardColor(20, QtGui.QColor( 23,  16,  24 , 0).rgba())    # Plu 4

color_Dialog.setStandardColor(26, QtGui.QColor(233, 185, 110 , 0).rgba())    # Chocolat 1
color_Dialog.setStandardColor(32, QtGui.QColor(193, 125,  17 , 0).rgba())    # Chocolat 2
color_Dialog.setStandardColor(38, QtGui.QColor(143,  89,   2 , 0).rgba())    # Chocolat 3
color_Dialog.setStandardColor(44, QtGui.QColor( 39,  25,   3 , 0).rgba())    # Chocolat 4
#### Dialog line 4
color_Dialog.setStandardColor( 3, QtGui.QColor(239,  41,  41 , 0).rgba())    # Scarle Re 1
color_Dialog.setStandardColor( 9, QtGui.QColor(204,   0,   0 , 0).rgba())    # Scarle Re 2
color_Dialog.setStandardColor(15, QtGui.QColor(164,   0,   0 , 0).rgba())    # Scarle Re 3
color_Dialog.setStandardColor(21, QtGui.QColor( 40,   0,   0 , 0).rgba())    # Scarle Re 4

color_Dialog.setStandardColor(27, QtGui.QColor( 52, 224, 226 , 0).rgba())    # FreeTea 1
color_Dialog.setStandardColor(33, QtGui.QColor( 22, 208, 210 , 0).rgba())    # FreeTea 2
color_Dialog.setStandardColor(39, QtGui.QColor(  6, 152, 154 , 0).rgba())    # FreeTea 3
color_Dialog.setStandardColor(45, QtGui.QColor(  4,  42,  42 , 0).rgba())    # FreeTea 4
#### Dialog line 5
color_Dialog.setStandardColor( 4, QtGui.QColor(255, 255, 255 , 0).rgba())    # Snow White

color_Dialog.setStandardColor(10, QtGui.QColor(238, 238, 236 , 0).rgba())    # Aluminiu 1
color_Dialog.setStandardColor(16, QtGui.QColor(211, 215, 207 , 0).rgba())    # Aluminiu 2
color_Dialog.setStandardColor(22, QtGui.QColor(186, 189, 182 , 0).rgba())    # Aluminiu 3

color_Dialog.setStandardColor(28, QtGui.QColor(136, 138, 133 , 0).rgba())    # Aluminiu 4
color_Dialog.setStandardColor(34, QtGui.QColor( 85,  87,  83 , 0).rgba())    # Aluminiu 5
color_Dialog.setStandardColor(40, QtGui.QColor( 46,  52,  54 , 0).rgba())    # Aluminiu 6

color_Dialog.setStandardColor(46, QtGui.QColor(  0,   0,   0 , 0).rgba())    # Je Black
#### Dialog line 6
color_Dialog.setStandardColor( 5, QtGui.QColor(255, 255, 255 , 0).rgba())    # Snow White
color_Dialog.setStandardColor(11, QtGui.QColor(255,   0,   0 , 0).rgba())    # Aluminiu 1
color_Dialog.setStandardColor(17, QtGui.QColor(  0, 255,   0 , 0).rgba())    # Aluminiu 2
color_Dialog.setStandardColor(23, QtGui.QColor(  0,   0, 255 , 0).rgba())    # Aluminiu 3

color_Dialog.setStandardColor(29, QtGui.QColor(255, 255,   0 , 0).rgba())    # Aluminiu 4
color_Dialog.setStandardColor(35, QtGui.QColor(255,   0, 255 , 0).rgba())    # Aluminiu 5
color_Dialog.setStandardColor(41, QtGui.QColor(  0, 255, 255 , 0).rgba())    # Aluminiu 6
color_Dialog.setStandardColor(47, QtGui.QColor(  0,   0,   0 , 0).rgba())    # Je Black
color_Dialog.setStandardColor(47, QtGui.QColor(  0,   0,   0 , 0).rgba())    # Je Black

#### Customize the colors to Dialog CustomColor (in hexadecimal converted in numeric mode)
# Use the Yellow tones for tools that create objects.
# Dialog line 1
color_Dialog.setCustomColor(0, QtGui.QColor( int("fc",16),int("e9",16),int("4f",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(2, QtGui.QColor( int("ed",16),int("d4",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(4, QtGui.QColor( int("c4",16),int("a0",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(6, QtGui.QColor( int("30",16),int("2b",16),int("00",16) , 0).rgba()) # hexadecimal converted in int

# Use the Blue tones for tools that modify objects
color_Dialog.setCustomColor(8, QtGui.QColor( int("72",16),int("9f",16),int("cf",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(10,QtGui.QColor( int("34",16),int("65",16),int("a4",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(12,QtGui.QColor( int("20",16),int("4a",16),int("87",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(14,QtGui.QColor( int("0b",16),int("15",16),int("21",16) , 0).rgba()) # hexadecimal converted in int

# Use the Teal tones for view-related tools
# Dialog line 2
color_Dialog.setCustomColor(1, QtGui.QColor( int("34",16),int("e0",16),int("e2",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(3, QtGui.QColor( int("16",16),int("d0",16),int("d2",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(5, QtGui.QColor( int("06",16),int("98",16),int("9a",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(7, QtGui.QColor( int("04",16),int("2a",16),int("2a",16) , 0).rgba()) # hexadecimal converted in int

# Use the Red tones for Constraint related tools
color_Dialog.setCustomColor(9, QtGui.QColor( int("ef",16),int("29",16),int("29",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(11,QtGui.QColor( int("cc",16),int("00",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(13,QtGui.QColor( int("a4",16),int("00",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
color_Dialog.setCustomColor(15,QtGui.QColor( int("28",16),int("00",16),int("00",16) , 0).rgba()) # hexadecimal converted in int

Color = color_Dialog.getColor()                                   # Color.name() extract the color in Hexadecimal mode (#ad7fa8)

if Color.isValid():

    print("__.name()___________")
    print("hexadecimal         ", Color.name())                   # color format hexadecimal mode 16
    red   = int(str( Color.name()[1:3]),16 )                      # decode hexadecimal to int()
    green = int(str( Color.name()[3:5]),16 )                      # decode hexadecimal to int()
    blue  = int(str( Color.name()[5:7]),16 )                      # decode hexadecimal to int()

    print("Red   color decimal ", str( Color.name()[1:3]), red )  # color format hex to decimal
    print("Green color decimal ", str( Color.name()[3:5]), green )# color format hex to decimal
    print("Blue  color decimal ", str( Color.name()[5:7]), blue ) # color format hex to decimal

    print("__.red()____________")
    print("Red   color decimal ", Color.red() )                   # extract the color RGBa with Qt (0 to 255)
    print("Green color decimal ", Color.green() )                 # extract the color RGBa with Qt (0 to 255)
    print("Blue  color decimal ", Color.blue() )                  # extract the color RGBa with Qt (0 to 255)
    print("Alpha       decimal ", Color.alpha() )                 # extract the color RGBa with Qt (0 to 255)

    print("__.redF()___________")
    print("Red   color float   ", Color.redF() )                  # extract the color RGBa with Qt (0.0 to 1.0) as FreeCAD
    print("Green color float   ", Color.greenF() )                # extract the color RGBa with Qt (0.0 to 1.0) as FreeCAD
    print("Blue  color float   ", Color.blueF() )                 # extract the color RGBa with Qt (0.0 to 1.0) as FreeCAD
    print("Alpha       float   ", Color.alphaF() )                # extract the color RGBa with Qt (0.0 to 1.0) as FreeCAD
    print("__enjoy_____________")

else:
    Color = ""


Visualizzare immagini con QLabel e Gif animate con QMovie

import PySide
from PySide import QtGui ,QtCore
from PySide.QtGui import QPixmap, QMovie, QLabel
from PySide.QtCore import *
class MyLabelPatience():
    label = QtGui.QLabel()
    label.setText("<img src=" + path_Name_Image + "><b><center>Wait please</center> \n\n<center>i search the fonts !\n\n</center></b>")
    # center screen
    ecran = FreeCADGui.getMainWindow().frameGeometry()
    xF = 250; yF = 120
    xW = (ecran.width()/2) - (xF/2)
    yW = (ecran.height()/2)- (yF/2)
    label.setGeometry(xW, yW, xF, yF)
    ####
    label.setStyleSheet("QLabel {background-color : #F0C300;font: 12pt; }");
    label.setWindowFlags(Qt.WindowFlags(Qt.FramelessWindowHint))        # pas de bords (not border)
    ### un-comment for use ###############
    movie = QtGui.QMovie(path_Name_Image)    # anime le fichier Gif anime (decommenter)
    label.setMovie(movie)
    movie.start()
    ##################

patience = MyLabelPatience().label
patience.show()                    #show the image
#patience.close()                   #close the Qlabel
#MyLabelPatience().movie.start()    #start the animation (after patience.show())
#MyLabelPatience().movie.stop()     #stop animation
  • Esempio di immagine e testo con QLabel
Example QLabel with image


  • Esempio di immagini animate Gif con QLabel
Example animated Gif

Alcuni comandi utili

# Here the code to display the icon on the '''pushButton''', 
# change the name to another button, ('''radioButton, checkBox''') as well as the path to the icon,

       # Displays an icon on the button PushButton
       # self.image_01 = "C:\Program Files\FreeCAD0.13\icone01.png" # he name of the icon
       self.image_01 = path+"icone01.png" # the name of the icon
       icon01 = QtGui.QIcon() 
       icon01.addPixmap(QtGui.QPixmap(self.image_01),QtGui.QIcon.Normal, QtGui.QIcon.Off)
       self.pushButton.setIcon(icon01) 
       self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button


# path = FreeCAD.ConfigGet("UserAppData") # gives the user path
  path = FreeCAD.ConfigGet("AppHomePath") # gives the installation path of FreeCAD

# This command reverses the horizontal button, right to left
self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the horizontal button

# Displays an info button
self.pushButton.setToolTip(_translate("MainWindow", "Quitter la fonction", None)) # Displays an info button

# This function gives a color button
self.pushButton.setStyleSheet("background-color: red") # This function gives a color button

# This function gives a color to the text of the button
self.pushButton.setStyleSheet("color : #ff0000") # This function gives a color to the text of the button

# combinaison des deux, bouton et texte
self.pushButton.setStyleSheet("color : #ff0000; background-color : #0000ff;" ) #  combination of the two, button, and text

# replace the icon in the main window
MainWindow.setWindowIcon(QtGui.QIcon('C:\Program Files\FreeCAD0.13\View-C3P.png'))

# connects a lineEdit on execute
self.lineEdit.returnPressed.connect(self.execute) # connects a lineEdit on "def execute" after validation on enter
# self.lineEdit.textChanged.connect(self.execute) # connects a lineEdit on "def execute" with each keystroke on the keyboard

# display text in a lineEdit
self.lineEdit.setText(str(val_X)) # Displays the value in the lineEdit (convert to string)

# extract the string contained in a lineEdit
 val_X = self.lineEdit.text() # extract the (string) string contained in lineEdit
 val_X = float(val_X0)        # converted the string to an floating
 val_X = int(val_X0)          # convert the string to an integer

# This code allows you to change the font and its attributes
       font = QtGui.QFont()
       font.setFamily("Times New Roman")
       font.setPointSize(10)
       font.setWeight(10)
       font.setBold(True) # same result with tags "<b>your text</b>" (in quotes)
       self.label_6.setFont(font)
       self.label_6.setObjectName("label_6")
       self.label_6.setStyleSheet("color : #ff0000") # This function gives a color to the text
       self.label_6.setText(_translate("MainWindow", "Select a view", None))

Utilizzando i caratteri accentati, si ottiene l'errore :

UnicodeDecodeError: 'utf8' codec can't decode bytes in position 0-2: invalid data

Sono possibili diverse soluzioni

# conversion from a lineEdit
App.activeDocument().CopyRight.Text = str(unicode(self.lineEdit_20.text() , 'ISO-8859-1').encode('UTF-8'))
DESIGNED_BY = unicode(self.lineEdit_01.text(), 'ISO-8859-1').encode('UTF-8')

o con la procedura

def utf8(unio):
    return unicode(unio).encode('UTF8')

UnicodeEncodeError: 'ascii' codec can't encode character u'\xe9' in position 9: ordinal not in range(128)

# conversion
a = u"Nom de l'élément : "
f.write('''a.encode('iso-8859-1')'''+str(element_)+"\n")

o con la procedura

def iso8859(encoder):
    return unicode(encoder).encode('iso-8859-1')

oppure

iso8859(unichr(176))

oppure

unichr(ord(176))

oppure

uniteSs = "mm"+iso8859(unichr(178))
print(unicode(uniteSs, 'iso8859'))

Relevant Links

Arrow-left.svg Funzione per disegnare linee Pagina precedente:
Pagina successiva: Licenza Arrow-right.svg

Sviluppare applicazioni per FreeCAD

Arrow-left.svg Creare dialoghi Pagina precedente:
Pagina successiva: Tracker Arrow-right.svg

Licenze utilizzate in FreeCAD

FreeCAD utilizza due licenze diverse, una per l'applicazione stessa e una per la documentazione:

Lesser General Public Licence, version 2 or superior (LGPL2+) For all of the FreeCAD source code found in the official Git repository

Creative Commons Attribution 3.0 License (CC-BY-3.0) For the documentation on http://www.freecadweb.org

See FreeCAD's debian copyright file for more details about the licenses used by the different open-source components used in FreeCAD

Impact of the licences

Below is a friendlier explanation of what the LGPL license means for you:

All users

Anybody can download, use and redistribute FreeCAD free of charge, without any restriction. Your copy of FreeCAD is truly yours, as are the files you produce with FreeCAD. You will not be forced to update FreeCAD after a certain time, nor change your usage of FreeCAD. Using FreeCAD doesn't bind you to any kind of contract or obligation. The FreeCAD source code is public and can be inspected, so it is possible to verify that it doesn't do things without your knowledge such as sending your private data somewhere.

Professional users

FreeCAD can be used freely for any kind of purpose, being private, commercial or institutional. Any version of FreeCAD can be deployed and installed anywhere, any number of times. You can also modify and adapt FreeCAD for your own purposes without any restriction. However, you cannot make the FreeCAD developers liable for possible damage or business loss that could occur from using FreeCAD.

Open-source software developers

You can use FreeCAD as a base to develop your own application, or simply extend it by creating new modules for it. If FreeCAD is embedded into your own application, you can choose either the GPL or the LGPL license, or any other license that is compatible with LGPL, to allow the use of your work in proprietary software or not. If you are developing a module to be used as an extension, and don't include any of the FreeCAD code in it, then you can choose any license you want. However, if you wish to see your module used as much as possible, it is a good idea to use the same LGPL license as FreeCAD itself, so parts of your code can be more easily reused in other future modules or even in FreeCAD itself.

Closed-source software developers

You can use FreeCAD as a base for your own application, and are not forced to make your application open source. The LGPL license, however, ask for two basic things: 1) that you clearly inform your users that your application is using FreeCAD and that FreeCAD is LGPL-licensed, and 2) that you clearly separate your own application form the FreeCAD components. That is usually done by either dynamically linking to the FreeCAD components, so users are allowed to change it, or making the FreeCAD source code, along with the modifications you brought to it, available to your users. You will get support from the FreeCAD developers as long as it is not a one way street.

Files

The models and other files produced with FreeCAD are not subject to any license stated above, nor bound to any kind of restriction or ownership. Your files are truly yours. You can set the owner of the file and specify your own license terms for the files you produce inside FreeCAD, via menu File → Project Information.

Statement of the main developer

I know that the discussion on the "right" licence for open source occupied a significant portion of internet bandwidth and so is here the reason why, in my opinion, FreeCAD should have this one.

I chose the LGPL for the project and I know the pro and cons about the LGPL and will give you some reasons for that decision.

FreeCAD is a mixture of a library and an application, so the GPL would be a little bit strong for that. It would prevent writing commercial modules for FreeCAD because it would prevent linking with the FreeCAD base libs. You may ask why commercial modules at all? Therefore Linux is good example. Would Linux be so successful when the GNU C Library would be GPL and therefore prevent linking against non-GPL applications? And although I love the freedom of Linux, I also want to be able to use the very good NVIDIA 3D graphic driver. I understand and accept the reason NVIDIA does not wish to give away driver code. We all work for companies and need payment or at least food. So for me, a coexistence of open source and closed source software is not a bad thing, when it obeys the rules of the LGPL. I would like to see someone writing a Catia import/export processor for FreeCAD and distribute it for free or for some money. I don't like to force him to give away more than he wants to. That wouldn't be good neither for him nor for FreeCAD.

Nevertheless this decision is made only for the core system of FreeCAD. Every writer of an application module may make his own decision.

Jürgen Riegel
—15 October 2006
Arrow-left.svg Creare dialoghi Pagina precedente:
Pagina successiva: Tracker Arrow-right.svg


Arrow-left.svg Licenze Pagina precedente:
Pagina successiva: Smistamento dei bug Arrow-right.svg

Potete segnalare i bug, presentare le richieste di funzionalità, patch, o richiedere di fondere un proprio ramo, se avete sviluppato qualcosa usando git. Il tracker è suddiviso in moduli, quindi cercate di essere specifici e di presentare la richiesta nella sottosezione appropriata. In caso di dubbio, lasciare il messaggio nella sezione "FreeCAD".


Flusso di lavoro raccomandato

Bugreport-workflow.png

Come mostrato nel diagramma di flusso sopra, prima di creare i ticket, cercare sempre prima nei forum e nel bugtracker per scoprire se il problema è già noto. Ciò consente di far risparmiare un sacco di tempo e di lavoro agli sviluppatori ed ai volontari che possono perciò dedicare più tempo per rendere FreeCAD ancora più fantastico.

Segnalare i bug

Quando si pensa di aver trovato un bug, si è invitati a segnalarlo lì, se si è prima discusso la questione nelle sedi opportune.

Prima di segnalare un bug, si prega di verificare i seguenti punti:

  • Assicurarsi che il problema è veramente un bug, cioè, qualcosa che dovrebbe funzionare e che non funziona. Se non si è sicuri, non esitare a esporre il problema nel forum e chiedere cosa fare.
  • Prima di inviare qualsiasi cosa, leggere le FAQ - domande frequenti, fare una ricerca nel forum e assicurarsi che lo stesso bug non è ancora stato segnalato, facendo una ricerca nel bug tracker.
  • Descrivere il più chiaramente possibile il problema e come può essere riprodotto. Se non possiamo verificare il bug, potremmo non essere in grado di risolvere il problema.
  • Includere tutte le informazioni usando il pulsante "Copia negli Appunti" del menu Aiuto -> A proposito di FreeCAD e farlo sia dall'ambiente Parte che dall'ambiente PartDesign in modo che siano inseriti i dati sulla versione OCC o OCE del sistema operativo utilizzato.
  • Si prega di inviare una relazione separata per ogni bug.
  • Quando si usa un sistema Linux e il bug causa un crash in FreeCAD, si può provare a eseguire un debug backtrace: Da un terminale eseguire gdb freecad (supponendo che il pacchetto gdb è installato), poi, all'interno di gdb, digitare run. FreeCAD viene eseguito e probabilmente causa un crash. A crash avvenuto, digitare bt, per ottenere il backtrace completo. Accludere al rapporto sul bug il risultato del backtrace emesso.

Richiedere delle nuove funzioni

Se desiderate qualcosa che in FreeCAD che non è ancora implementato, it is not a bug but a feature request questo non è un bug, ma una richiesta di nuove funzionalità.

  1. IMPORTANTː Before requesting a potential Feature Request please be certain that you are the first one doing so by searching the forums and the bugtracker. If you have concluded that there are no pre-existing tickets/discussions the next step is toː
  2. Start a forum thread to discuss your feature request with the community via the Open Discussion forum.
  3. Once the community agrees that this is a valid Feature, you then can open a ticket on the tracker (file it under feature request instead of bug).
  • NOTE #1 To keep things organized please remember to link the forum thread URL into the ticket and the ticket number (as a link) in to the forum thread.
  • NOTE #2 Keep in mind there are no guarantees that your wish will be fulfilled.
FreeCAD Bugtracker report page - use the dropdown to correctly designate what the ticket is

Inviare patch

Se avete creato il programma di correzione a un bug, una estensione o altro che può essere di uso pubblico in FreeCAD, create una patch utilizzando lo strumento Git diff e presentatela utilizzando il medesimo tracker (il file è una patch).

Addendumː FreeCAD development has switched to the GitHub development model so the workflow for submitting patches has been greatly enhanced/streamlined by submitting Pull Requests.

  • Open a forum thread in the Developer subforum to announce and discuss your patch.
  • Submit your PR to the FreeCAD GitHub repo. Be sure to link the forum thread in to the git commit summary.
  • Paste the PR link in to the forum thread for the devs/testers to test.
  • Be present for the discussion so that your code can potentially be merged more effectively.

NOTEː the FreeCAD community recommends to first discuss any large revision to the source code in advance to save everyone time.

Richiedere la fusione

(Stesse linee guida di come Inviare delle patches)

Se avete creato un ramo git contenente delle modifiche che desiderate far confluire nel codice di FreeCAD, potete fare la richiesta di avere la recensione e la fusione del vostro ramo, se ​​gli sviluppatori di FreeCAD sono d'accordo. È necessario pubblicare prima il ramo in un repository git pubblico (github, bitbucket, sourceforge ...) e poi fornire l'URL del vostro ramo nella richiesta di unione.

MantisBT Tips and Tricks

MantisBT Markup

MantisBT (Mantis Bug Tracker) has it's own unique markup.

  • @mention - works just like on GitHub where if you prepend '@' to someone's username they will receive an email that they have been 'mentioned' in a ticket thread
Mantisbt-mention-example.jpg
  • #1234 - By adding a hash tag in front of a number a shortcut to link to another ticket within MantisBT will present.
    Note: if you hover over a ticket it will show you the summary + if the ticket is closed, it will be struck-through like #1234.
Mantisbt-ticket-shortcut-example.jpg
  • ~5678 - a shortcut that links to a bug note within a ticket. This can be used to reference someone's response within the thread. Each person that posts will show a unique ~#### number next to their username. If you look at the image in the example, you see that the shortcut is referencing the ticket number:comment number of said ticket
Mantisbt-comment-shortcut-example.jpg
  • <del></del> - Using these tags will strikeout text.
Mantisbt-strikeout-text-example.jpg
  • <code></code> - To present a line or block of code, use this tag and it will colorize and differentiate it elegantly.
Mantisbt-colorized-code-example.jpg

MantisBT BBCode

In addition to the above Tracker/MantisBT ̠Markup one also has the possibility to use BBCode format. For a comprehensive list see the BBCode plus plugin page. Here is a list of supported BBCode tagsː
[img][/img] - Images
[url][/url] - Links
[email][/email] - Email addresses
[color=red][/color] - Colored text
[highlight=yellow][/highlight] - Highlighted text
[size][/size] - Font size
[list][/list] - Lists
[list=1][/list] - Numbered lists (number is starting number)
[*] - List items
[b][/b] - Bold
[u][/u] - underline
[i][/i] - Italic
[s][/s] - Strikethrough
[left][/left] - Left align
[center][/center] - Center
[right][/right] - Right align
[justify][/justify] - Justify
[hr] - Horizontal rule
[sub][/sub] - Subscript
[sup][/sup] - Superscript
[table][/table] - Table
[table=1][/table] - Table with border of specified width
[tr][/tr] - Table row
[td][/td] - Table column
[code][/code] - Code block
[code=sql][/code] - Code block with language definition
[code start=3][/code] - Code block with line numbers starting at number
[quote][/quote] - Quote by *someone* (no name)
[quote=name][/quote] - Quote by *name*

MantisBT <=> GitHub Markup

Below are special MantisBT Source-Integration plugin keywords which will link to the FreeCAD GitHub repo. See Tracker#GitHub_and_MantisBT.

  • c:FreeCAD:git commit hash: - c stands for 'commit'. FreeCAD stands for the FreeCAD GitHub repo. 'git commit hash' is the specific git commit hash to reference. Note: the trailing colon is necessary. Exampleː cːFreeCADː709d2f325db0490016807b8fa6f49d1c867b6bd8ː
  • d:FreeCAD:git commit hash: - similar to the above, d stands for 'diff' which will provide a Diff view of the commit. Exampleː dːFreeCADː709d2f325db0490016807b8fa6f49d1c867b6bd8ː
  • p:FreeCAD:pullrequest: - similar to the above, p stands for Pull Request. Exampleː pːFreeCADː498ː
Mantisbt-source-integration-markup.jpg


GitHub and MantisBT

The FreeCAD bugtracker has a plug-in called Source Integration which essentially ties both the FreeCAD GitHub repo to our MantisBT tracker. It makes it easier to track and associate git commits with their respective MantisBT tickets. The Source Integration plugin scans the git commit messages for specific keywords in order to execute the following actions:

Note The below keywords need to be added in the git commit message and not the PR subject

Remotely referencing a ticket

Using this pattern will automagically associate a git commit to a ticket (Note: this will not close the ticket.) The format MantisBT will recognize:

  • bug #1234
  • bugs #1234, #5678
  • issue #1234
  • issues #1234, #5678
  • report #1234
  • reports #1234, #5678

For the inquisitive here is the regex MantisBT uses for this operation:
/(?:bugs?|issues?|reports?)+\s*:?\s+(?:#(?:\d+)[,\.\s]*)+/i

Remotely resolving a ticket

The format MantisBT will recognize:

  • fix #1234
  • fixed #1234
  • fixes #1234
  • fixed #1234, #5678
  • fixes #1234, #5678
  • resolve #1234
  • resolved #1234
  • resolves #1234
  • resolved #1234, #5678
  • resolves #1234, #5678

For the inquisitive here is the regex MantisBT uses for this operation:
/(?:fixe?d?s?|resolved?s?)+\s*:?\s+(?:#(?:\d+)[,\.\s]*)+/i

Pagine correlate

Arrow-left.svg Licenze Pagina precedente:
Pagina successiva: Smistamento dei bug Arrow-right.svg


Arrow-left.svg Tracker Pagina precedente:
Pagina successiva: Compilazione in Unix Arrow-right.svg

Questo articolo spiega passo dopo passo come compilare FreeCAD su Windows.

Prerequisiti

Programmi richiesti

  • Git Ci sono una serie di alternative come GitCola, Tortoise Git, e altri.
  • CMake versione 2.x.x oppure Cmake 3.x.x
  • Python >2.5 (Questo è necessario solo se non si utilizza il Libpack. Il Libpack è dotato come minimo di Python(2.7.x) idoneo per compilare e eseguire FreeCAD)

Codice sorgente

Usando Git (Preferito)

Per creare un ramo locale e scaricare il codice sorgente è necessario aprire un terminale (prompt dei comandi) e portarsi nella directory (cd) in cui si desidera creare il sorgente, quindi digitare:

git clone https://github.com/FreeCAD/FreeCAD.git FreeCAD-code

Compilatore

In Windows, il compilatore di default è MS Visual Studio, sia che si tratti della versione Express oppure Completa 2008, 2012, o 2013.

Per chi vuole evitare l'installazione completa dell'ingombrante Visual Studio al solo scopo di avere un compilatore può vedere Compilare in Windows - Occupare meno spazio.

Note

Sebbene possa essere possibile utilizzare Cygwin o MinGW gcc, non è stato testato o portato fino ad ora.


Librerie di terze parti

Per compilare correttamente FreeCAD, servono tutte le Librerie di terze parti . Se si usa i compilatori MS si raccomanda di installare FreeCAD LibPack,che fornisce tutte le librerie necessarie per costruire FreeCAD in Windows. Serve il Libpack adatto alla propria architettura e compilatore. Attualmente FreeCAD fornisce Libpack Version11 per x32 e x64, per VS9 2008, VS11 2012, e VS12 2013.

Programmi opzionali

  • NSIS installatore Windows (nota: prima era usato l'installatore WiX - ora è in corso il passaggio a NSIS) - per creare un installatore msi

System Path Configuration

All'interno del percorso di sistema assicurarsi di impostare i percorsi corretti per i seguenti programmi:

  • git (non tortoiseGit, ma git.exe) Serve a Cmake per aggiornare correttamente le informazioni "About FreeCAD" nel file version.h che consente a FreeCAD di riportare la versione corretta in About FreeCAD dal menu Aiuto.
  • Opzionalmente è possibile includere il Libpack nel percorso di sistema. Questo è utile se si prevede di costruire più configurazioni o versioni di FreeCAD, si dovranno copiare meno file, come spiegato più avanti nel processo di costruzione.

Per aggiungere al percorso di sistema:

  • Menu di avvio → Fare clic con il pulsante destro del mouse su Computer → Proprietà → Impostazioni di sistema avanzate
  • Scheda Avanzate → Variabili d'ambiente ...
  • Aggiungi il PATH/TO/GIT to the PATH
  • Dovrebbe essere separato dagli altri con un punto e virgola `;`

Configurazione con CMake

Il passaggio a CMake

Attenzione

Da FreeCAD versione 0.9 abbiamo smesso di fornire i file .vcproj.

Attualmente, FreeCAD utilizza il sistema di compilazione CMake per generare build e creare file che possono essere utilizzati tra diversi sistemi operativi e compilatori. Se vuoi creare versioni precedenti di FreeCAD (0.8 e precedenti) vedi Costruire versioni precedenti più avanti in questo articolo.

Siamo passati perché è diventato sempre più doloroso mantenere i file di progetto per 30+ costruire obiettivi e x compilatori. CMake ci dà la possibilità di supportare alternative IDE, come Code :: Blocks, Qt Creator ed Eclipse CDT. Il compilatore principale è ancora MS VC9 Express, comunque. Ma pianifichiamo per il futuro un processo di costruzione Windows senza software di compilazione proprietario.

CMake

Il primo passo per creare FreeCAD con CMake è configurare l'ambiente. Là sono due modi per farlo:

  • Utilizzo di LibPack
  • Installare tutte le librerie necessarie e lasciare che CMake le trovi


Il seguente processo presuppone che stai usando LibPack. La seconda opzione può essere discussa nel Options for the Build Process.

Configure CMake using GUI

  • Apri la GUI di CMake
  • Specificare la cartella di origine
  • Specificare la cartella di build
  • Clicca Configura
  • Specifica il generatore in base all'IDE che utilizzerai.


Questo inizierà la configurazione e dovrebbe fallire perché la posizione di FREECAD_LIBPACK_DIR è disinserito.

  • Espandi la categoria FREECAD e imposta FREECAD_LIBPACK_DIR nella posizione corretta
  • Check FREECAD_USE_EXTERNAL_PIVY
  • Facoltativamente Check FREECAD_USE_FREETYPE questo è necessario per utilizzare la funzionalità String di forma di Draft WB
  • Clic Configure ancora
  • Non ci dovrebbero essere errori
  • Clic Generate
  • Chiudi CMake
  • Copia cartella libpack\bin nella nuova cartella di creazione creata da CMake

Opzioni per il processo di compilazione

Il sistema di build CMake ci offre molta più flessibilità durante il processo di costruzione. Questo significa possiamo attivare e disattivare alcune funzioni o moduli. È come la compilazione del kernel di Linux. Hai un sacco di opzioni per determinare il processo di compilazione.

Ecco la descrizione di alcuni di questi interruttori. Molto probabilmente cambieranno molto in futuro perché vogliamo aumentare la flessibilità di costruzione molto di più.


Link table
Nome variabile Descrizione Predefinito
FREECAD_LIBPACK_USE Attivare o disattivare l'uso di FreeCAD LibPack Su Win32 acceso, altrimenti spento
FREECAD_LIBPACK_DIR Directory in cui si trova LibPack FreeCAD SOURCE dir
FREECAD_BUILD_GUI Costruisci FreeCAD con tutti i moduli relativi a Gui ON
FREECAD_BUILD_CAM Costruisci il modulo CAM, sperimentale! OFF
FREECAD_BUILD_INSTALLER Creare i file di progetto per il programma di installazione di Windows. OFF
FREECAD_BUILD_DOXYGEN_DOCU Creare i file di progetto per la documentazione del codice sorgente. OFF
FREECAD_MAINTAINERS_BUILD Attivare le cose necessarie solo quando si esegue una build di rilascio. OFF

Se stai costruendo con Qt Creator, vai a Costruire con Qt Creator, altrimenti procedere a Costruire con Visual Studio 9 2008.

Costruzione di FreeCAD

A seconda della configurazione corrente, il processo di creazione di FreeCAD sarà leggermente diverso. Ciò è dovuto alle differenze nelle versioni software e software disponibili per ciascun sistema operativo.


La seguente procedura funzionerà per la compilazione su Windows Vista / 7/8, per XP è necessario un set di strumenti VS alternativo per VS 2012 e 2013, che non è stato testato con successo con gli attuali Libpacks. Per targetizzare XP (entrambi x32 e x64) si consiglia di utilizzare VS2008 e Libpack FreeCADLibs_11.0_x86_VC9.7z

Costruire con Visual Studio 12 2013

Assicurati di specificare Visual Studio 12 x64 (o il C-Compiler alternativo che stai utilizzando) come generatore in CMake prima di continuare.

  • Avviare Visual Studio 12 2013 facendo clic sull'icona del desktop creata durante l'installazione.
  • Apri il progetto da:

File → Open → Project/Solution

  • Aprire FreeCAD_Trunk.sln dalla cartella di creazione creata da CMake
  • Passa al menu a discesa Configurazione soluzioni in alto a Rilascia X64

Questo potrebbe richiedere del tempo a seconda del sistema

  • Build → Build Solution
  • Ci vorrà molto tempo ...

Se non ricevi errori, hai finito. Uscire da Visual Studio e avviare FreeCAD facendo doppio clic sull'icona di FreeCAD nella cartella bin della directory di build.


Costruire con Visual Studio 9 2008

Avvertenza

Dall'inizio del ciclo 0.17 Freecad utilizza le funzioni di c++11 che non sono supportate dalla versione 2008



Costruire con Qt Creator

Installazione e configurazione di Qt Creator

  • Scarica e installa Qt Creator
  • Strumenti → Opzioni → Editor di testo → scheda Comportamento:
    • Codifica dei file → Codifiche predefinite:
    • Impostato su: ISO-8859-1 /...csISOLatin1 (Alcuni caratteri creano errori / avvertimenti con Qt Creator se lasciato impostato su UTF-8. Questo sembra risolverlo.)
  • Strumenti → Opzioni → Crea ed esegui:
    • Scheda CMake
      • Riempi la casella Eseguibile con il percorso di cmake.exe
    • Scheda Kit
      • Nome: MSVC 2008
      • Compilatore: Microsoft Visual C++ Compiler 9.0 (x86)
      • Debugger: rilevato automaticamente ...
      • Versione Qt: Nessuna
    • Scheda Generale
      • Deselezionare: crea sempre un progetto prima di distribuirlo
      • Deselezionare: distribuire sempre il progetto prima di eseguirlo

Importa progetto e crea

  • File → Apri file o progetto
  • Apri CMakeLists.txt che si trova nel livello più alto della fonte
  • Questo avvierà CMake
  • Scegli la cartella di costruzione e fai clic su Avanti
  • Imposta generatore su NMake Generator (MSVC 2008)
  • Clicca Esegui CMake. Segui le istruzioni illustrate sopra per configurare CMake a tuo piacimento.

Ora è possibile creare FreeCAD

  • Build → Build All
  • Ci vorrà molto tempo ...

Una volta completato, può essere eseguito: Ci sono 2 triangoli verdi in basso a sinistra. Uno è il debug. L'altro è eseguito. Scegli quello che vuoi.


Configurazione della riga di comando

Ecco un esempio su come creare FreeCAD dalla riga di comando:

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

Costruire versioni precedenti

utilizzando LibPack

Per rendere più semplice la compilazione di FreeCAD, forniamo una raccolta di tutti librerie necessarie Si chiama LibPack. Puoi trovarlo sulla download page su sourceforge.

È necessario impostare le seguenti variabili di ambiente:

FREECADLIB = "D:\Wherever\LIBPACK"
QTDIR = "%FREECADLIB%"

Add "%FREECADLIB%\bin" e "%FREECADLIB%\dll" alla variabile "PATH" del sistema. Ricordare che è necessario sostituire "%FREECADLIB%" con il nome del percorso, poiché Windows non sostituisce in modo ricorsivo le variabili di ambiente.

Configurazione della directory in Visual Studio

È necessario impostare un percorso di ricerca di Visual Studio. Per cambiarli, usa il menu Tools → Options → Directory

Includes

Aggiungi il seguente percorso di ricerca all'elenco di ricerca del percorso di inclusione:

  •  %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

Aggiungi il seguente percorso di ricerca all'elenco di ricerca del percorso lib:

  •  %FREECADLIB%\lib
Executables

Aggiungi il seguente percorso di ricerca all'elenco di ricerca del percorso eseguibile:

  •  %FREECADLIB%\bin
  • Directory di installazione binaria TortoiseSVN, di solito "C:\Programm Files\TortoiseSVN\bin", questo è necessario per una build di distribuzione quando SubWVRev.exe è usato per estrarre il numero di versione da Subversion.

Python necessario

Durante la compilazione vengono eseguiti alcuni script Python. Quindi il Python l'interprete deve funzionare sul sistema operativo. Utilizzare una casella di comando per controllarlo. Se la libreria Python non è installata correttamente si otterrà un messaggio di errore come "Impossibile trovare python.exe". Se usi LibPack puoi anche usare il Python.exe nella directory bin.

Special for VC8

Quando si crea il progetto con VC8, è necessario modificare le informazioni sul collegamento per la libreria WildMagic, poiché è necessaria una versione diversa per VC6 e VC8. Entrambe le versioni sono fornite in LIBPACK/dll. Nelle proprietà del progetto per AppMesh cambia il nome della libreria per il wm.dll alla versione VC8. Fai attenzione a cambiarlo in Debug e Rilascia configurazione.

Compilare

Dopo esserti conformato a tutti i prerequisiti, la compilazione è - hopefully - only a mouse click in VC

Dopo la compilazione

Per far partire FreeCAD dall'ambiente del compilatore è necessario copiare alcuni file da LibPack nella cartella bin in cui FreeCAD.exe è installato dopo una compilazione avvenuta con successo:

  • python.exe e python_d.exe from LIBPACK/bin
  • python25.dll e python25_d.dll a partire dal LIBPACK/bin
  • python25.zip a partire dal LIBPACK/bin
  • fare una copia di Python25.zip e rinominalo Python25_d.zip
  • QtCore4.dll a partire dal LIBPACK/bin
  • QtGui4.dll a partire dal LIBPACK/bin
  • boost_signals-vc80-mt-1_34_1.dll a partire dal LIBPACK/bin
  • boost_program_options-vc80-mt-1_34_1.dll a partire dal LIBPACK/bin
  • xerces-c_2_8.dll a partire dal LIBPACK/bin
  • zlib1.dll a partire dal LIBPACK/bin
  • coin2.dll a partire dal LIBPACK/bin
  • soqt1.dll a partire dal LIBPACK/bin
  • QtOpenGL4.dll a partire dal LIBPACK/bin
  • QtNetwork4.dll a partire dal LIBPACK/bin
  • QtSvg4.dll a partire dal LIBPACK/bin
  • QtXml4.dll a partire dal LIBPACK/bin

Quando si utilizza LibPack con una versione di Python precedente alla 2.5 devi copiare altri due file:

  • zlib.pyd e zlib_d.pyd from LIBPACK/bin/lib. Questo è richiesto da python per aprire la libreria Python zippata.
  • _sre.pyd e _sre_d.pyd from LIBPACK/bin/lib. Questo è richiesto da Python per il sistema di aiuto integrato.

Se non lo si esegue a causa di un errore di Python, è molto probabile che manchi uno dei file zlib*.pyd.

In alternativa, puoi copiare l'intera cartella bin di libpack nella cartella bin della build. Questo è più semplice, ma richiede tempo e spazio su disco. Questo può essere sostituito facendo collegamenti invece di copiare file, vedi CompileOnWindows - Reducing Disk Footprint.

Altre cose

Se si desidera creare la documentazione del codice sorgente necessaria DoxyGen.

Per creare un pacchetto di installazione che ti serve WIX.

Durante la compilazione vengono eseguiti alcuni script Python. Quindi l'interprete Python deve funzionare correttamente.

Per ulteriori dettagli è inoltre possibile consultare "README.Linux" nelle origini.

Prima di tutto dovresti creare il plugin Qt che fornisce tutti i widget personalizzati di FreeCAD di cui abbiamo bisogno per Qt Designer. Le fonti si trovano sotto.

//src/Tools/plugins/widget//.

Finora non forniamo un makefile -- ma chiamiamo

qmake plugin.pro

lo crea. Una volta fatto, chiamare "make" creerà la libreria

//libFreeCAD_widgets.so//.

Per rendere questa libreria nota al tuo "Qt Designer" devi copiare il file in

//$QTDIR/plugin/designer//.

Riferimenti

Arrow-left.svg Tracker Pagina precedente:
Pagina successiva: Compilazione in Unix Arrow-right.svg


Nelle distribuzioni Linux recenti FreeCAD si compila facilmente, dato che di solito tutte le dipendenze sono fornite dal gestore di pacchetti. Fondamentalmente si tratta di eseguire 3 passaggi:

  1. Ottenere il codice sorgente di FreeCAD
  2. Ottenere le dipendenze (i pacchetti da cui dipende FreeCAD)
  3. Configurare con "cmake" e compilare con "make"

Qui, di seguito, troverete le spiegazioni dettagliate di tutto il processo, delle particolarità che si possono incontrare e alcuni script di build,. Se trovate qualcosa di sbagliato o di non aggiornato nel testo successivo (le distribuzioni Linux cambiano spesso), o se utilizzate una distribuzione che non è elencata, per favore aiutateci a correggerlo.

FreeCAD source compilation workflow.svg

General workflow to compile FreeCAD from source. The third party dependencies must be in the system, as well as the FreeCAD source code itself. CMake configures the system so that with a single make instruction the entire project is compiled.


Ottenere il sorgente

Per poter compilare FreeCAD è necessario il codice sorgente. Ci sono 3 modi per ottenerlo:

Git

Il modo migliore e più veloce per ottenere il codice è quello di clonare il repository git di sola lettura ora ospitato in GitHub (bisogna avere il pacchetto git installato):

Questo crea una copia locale della versione più recente del codice sorgente di FreeCAD in una nuova directory chiamata "freecad-code".

sudo apt install git
git clone https://github.com/FreeCAD/FreeCAD.git freecad-source

For more information on using Git, and contributing code to the project, see Source code management.

Pacchetto sorgente

In alternativa è possibile scaricare il pacchetto sorgente, ma potrebbe già essere abbastanza vecchio, e quindi è sempre meglio ottenere i sorgenti più recenti tramite git o github.

Ottenere le dipendenze

Per compilare FreeCAD sotto Linux è necessario installare prima tutte le librerie indicate nella pagina Librerie di terze parti. Notare che i nomi e la disponibilità delle librerie dipendono dalla vostra distribuzione. Notare che se non si utilizza la versione più recente della propria distribuzione, alcuni dei pacchetti indicati in seguito potrebbero mancare dal vostro repository. In questo caso, cercare nel paragrafo sottostante dedicato alle Distribuzioni vecchie e non convenzionali.

Passa al paragrafo Compilare FreeCAD

Please note that FreeCAD's source code is around 500 MB in size; it may be three times as big if you clone the Git repository with its entire modification history. Getting all dependencies may require downloading 500 MB or more of new files; when these files are unpacked they may require 1500 MB or more in space. Also beware that the compilation process may generate up to 1500 MB of additional files as the system copies and modifies the entire source code. Therefore, be sure you have enough free space in your hard drive, at least 4 GB, when attempting compilation.

Debian e Ubuntu

Su sistemi Debian-based (Debian, Ubuntu, Mint, etc...) è abbastanza facile ottenere tutte le dipendenze che devono essere installate. La maggior parte delle librerie sono disponibili tramite apt-get o il gestore dei pacchetti synaptic.

If you already installed FreeCAD from the official repositories, you can install its build dependencies with this single line of code in a terminal:

sudo apt build-dep freecad

However, if the version of FreeCAD in the repositories is old, the dependencies may be the wrong ones to compile a recent version of FreeCAD. Therefore, please verify that you have installed the following packages.

These packages are essential for any sort of compilation to succeed:

  • build-essential, installs the C and C++ compilers, the C development libraries, and the make program.
  • cmake, essential tool to configure the source of FreeCAD. You may also wish to install cmake-gui and cmake-curses-gui for a graphical option.
  • libtool, essential tools to produce shared libraries.
  • lsb-release, the standard base reporting utility is normally already installed in a Debian system, and allows you to programmatically distinguish between a pure Debian installation or a variant, such as Ubuntu or Linux Mint. Do not remove this package, as many other system packages may depend on it.

Compilation of FreeCAD uses the Python language, and it's also used at runtime as a scripting language. If you are using a Debian based distribution the Python interpreter is normally already installed.

  • python3
  • swig, the tool that creates interfaces between C++ code and Python.

Please check that you have Python 3 installed. Python 2 was obsoleted in 2019, so new development in FreeCAD is not tested with this version of the language.

The Boost libraries need to be installed:

  • libboost-dev
  • libboost-date-time-dev
  • libboost-filesystem-dev
  • libboost-graph-dev
  • libboost-iostreams-dev
  • libboost-program-options-dev
  • libboost-python-dev
  • libboost-regex-dev
  • libboost-serialization-dev
  • libboost-signals-dev
  • libboost-thread-dev

The Coin libraries need to be installed:

  • libcoin80-dev, for Debian Jessie, Stretch, Ubuntu 16.04 to 18.10, or
  • libcoin-dev, for Debian Buster, Ubuntu 19.04 and newer, as well as for Ubuntu 18.04/18.10 with the freecad-stable/freecad-daily PPAs added to your software sources.

Several libraries that deal with mathematics, triangulated surfaces, sorting, meshes, computer vision, cartographic projections, 3D visualization, the X11 Window system, XML parsing, and Zip file reading:

  • libeigen3-dev
  • libgts-bin
  • libgts-dev
  • libkdtree++-dev
  • libmedc-dev
  • libopencv-dev or libcv-dev
  • libproj-dev
  • libvtk7-dev or libvtk6-dev
  • libx11-dev
  • libxerces-c-dev
  • libzipios++-dev

Python 2 and Qt4

This is not recommended for newer installations as both Python 2 and Qt4 are obsolete.

To compile FreeCAD for Debian Jessie, Stretch, Ubuntu 16.04, using Python 2 and Qt4, install the following dependencies.

  • qt4-dev-tools
  • libqt4-dev
  • libqt4-opengl-dev
  • libqtwebkit-dev
  • libshiboken-dev
  • libpyside-dev
  • pyside-tools
  • python-dev
  • python-matplotlib
  • python-pivy
  • python-ply
  • python-pyside

Python 3 and Qt5

To compile FreeCAD for Debian Buster, Ubuntu 19.04 and newer, as well as Ubuntu 18.04/18.10 with the freecad-stable/freecad-daily PPAs added to your software sources, install the following dependencies.

  • qtbase5-dev
  • qttools5-dev
  • libqt5opengl5-dev
  • libqt5svg5-dev
  • libqt5webkit5-dev or qtwebengine5-dev
  • libqt5xmlpatterns5-dev
  • libqt5x11extras5-dev
  • libpyside2-dev
  • libshiboken2-dev
  • pyside2-tools
  • python3-dev
  • python3-matplotlib
  • python3-pivy
  • python3-ply
  • python3-pyside2.qtcore
  • python3-pyside2.qtgui
  • python3-pyside2.qtsvg
  • python3-pyside2.qtwidgets
  • python3-pyside2uic

OpenCascade kernel

The OpenCascade kernel is the core graphics library to create 3D shapes. It exists in an official version OCCT, and a community version OCE. The community version is no longer recommended, as it's outdated.

For Debian Buster and Ubuntu 18.10 and newer, as well as Ubuntu 18.04 with the freecad-stable/freecad-daily PPAs added to your software sources, install the official packages.

  • libocct*-dev
    • libocct-data-exchange-dev
    • libocct-draw-dev
    • libocct-foundation-dev
    • libocct-modeling-algorithms-dev
    • libocct-modeling-data-dev
    • libocct-ocaf-dev
    • libocct-visualization-dev
  • occt-draw

For Debian Jessie, Stretch, Ubuntu 16.04 and newer, install the community edition packages.

  • liboce*-dev
    • liboce-foundation-dev
    • liboce-modeling-dev
    • liboce-ocaf-dev
    • liboce-ocaf-lite-dev
    • liboce-visualization-dev
  • oce-draw

Notare che liboce*-dev include le seguenti librerie:

sudo apt install libocct*-dev

Opzionalmente è anche possibile installare questi pacchetti extra:

Single command for Python 3 and Qt5

Requires Pyside2 available in Debian buster and the freecad-stable/freecad-daily PPAs.

sudo apt install cmake cmake-gui libboost-date-time-dev libboost-dev libboost-filesystem-dev libboost-graph-dev libboost-iostreams-dev libboost-program-options-dev libboost-python-dev libboost-regex-dev libboost-serialization-dev libboost-signals-dev libboost-thread-dev libcoin-dev libeigen3-dev libgts-bin libgts-dev libkdtree++-dev libmedc-dev libocct-data-exchange-dev libocct-ocaf-dev libocct-visualization-dev libopencv-dev libproj-dev libpyside2-dev libqt5opengl5-dev libqt5svg5-dev libqt5webkit5-dev libqt5x11extras5-dev libqt5xmlpatterns5-dev libshiboken2-dev libspnav-dev libvtk7-dev libx11-dev libxerces-c-dev libzipios++-dev occt-draw pyside2-tools python3-dev python3-matplotlib python3-pivy python3-ply python3-pyside2.qtcore python3-pyside2.qtgui python3-pyside2.qtsvg python3-pyside2.qtwidgets python3-pyside2uic qtbase5-dev qttools5-dev swig

Single command for Python 2 and Qt4

This is not recommended for newer installations as both Python 2 and Qt4 are obsolete.

sudo apt install cmake debhelper dh-exec dh-python libboost-date-time-dev libboost-dev libboost-filesystem-dev libboost-graph-dev libboost-iostreams-dev libboost-program-options-dev libboost-python-dev libboost-regex-dev libboost-serialization-dev libboost-signals-dev libboost-thread-dev libcoin80-dev libeigen3-dev libgts-bin libgts-dev libkdtree++-dev libmedc-dev libocct-data-exchange-dev libocct-ocaf-dev libocct-visualization-dev libopencv-dev libproj-dev libpyside-dev libqt4-dev libqt4-opengl-dev libqtwebkit-dev libshiboken-dev libspnav-dev libvtk6-dev libx11-dev libxerces-c-dev libzipios++-dev lsb-release occt-draw pyside-tools python-dev python-matplotlib python-pivy python-ply swig

Gli utenti di Ubuntu 16.04 vedano anche queste ulteriori instruzioni .

Fedora

Sono necessari i seguenti pacchetti:

  • gcc-c++ (or possibly another C++ compiler?)
  • cmake
  • doxygen
  • swig
  • gettext
  • dos2unix
  • desktop-file-utils
  • libXmu-devel
  • freeimage-devel
  • mesa-libGLU-devel
  • OCE-devel
  • python
  • python-devel
  • python-pyside-devel
  • pyside-tools
  • boost-devel
  • tbb-devel
  • eigen3-devel
  • qt-devel
  • qt-webkit-devel
  • ode-devel
  • xerces-c
  • xerces-c-devel
  • opencv-devel
  • smesh-devel
  • coin3-devel

(if coin2 is the latest available for your version of Fedora, use packages from http://www.zultron.com/rpm-repo/)

  • soqt-devel
  • freetype
  • freetype-devel

E opzionalmente:

Gentoo

Il modo più semplice per controllare quali pacchetti sono necessari per compilare FreeCAD è quello di verificare tramite Portage:

emerge -pv freecad

Questo dovrebbe dare una bella lista di pacchetti extra che è necessario installare sul proprio sistema.

If FreeCAD is not available on portage, it is available on the waebbl overlay. The issue tracker on the waebbl overlay Github may help guide through some issues you may come across. The overlay provides freecad-9999, which you can choose to compile, or simply use to get the dependencies.

layman -a waebbl </div> </div>

openSUSE

Tumbleweed

The following commands will install the packages required for building FreeCAD with Qt5 and Python 3.

zypper in --no-recommends -t pattern devel_C_C++ devel_qt5

zypper in libqt5-qtbase-devel libqt5-qtsvg-devel libqt5-qttools-devel boost-devel swig libboost_program_options-devel libboost_mpi_python3-devel libboost_system-devel libboost_program_options-devel libboost_regex-devel libboost_python3-devel libboost_thread-devel libboost_system-devel libboost_headers-devel libboost_graph-devel python3 python3-devel python3-matplotlib python3-matplotlib-qt5 python3-pyside2 python3-pyside2-devel python3-pivy gcc gcc-fortran cmake occt-devel libXi-devel opencv-devel libxerces-c-devel Coin-devel SoQt-devel freetype2-devel eigen3-devel libode6 vtk-devel libmed-devel hdf5-openmpi-devel openmpi2-devel netgen-devel freeglut-devel libspnav-devel f2c doxygen dos2unix glew-devel

The following command will install Qt Creator and the GNU Project Debugger.

zypper in libqt5-creator gdb

If any packages are missing, then you can check the Tumbleweed "FreeCAD.spec" file on the Open Build Service.

Also, check to see if there are any patches you need to apply (such as 0001-find-openmpi2-include-files.patch).

Leap

If there is a difference between the available packages on Tumbleweed and Leap, then you can read the Leap "FreeCAD.spec" file on the Open Build Service to determine the required packages.

Arch Linux

You will need the following libraries from the official repositories:

  • boost-libs
  • curl
  • desktop-file-utils
  • glew
  • hicolor-icon-theme
  • jsoncpp
  • libspnav
  • med
  • opencascade
  • shiboken2
  • xerces-c
  • pyside2
  • python-matplotlib
  • python-netcdf4
  • qt5-svg
  • qt5-webkit
  • qt5-webengine
  • boost
  • cmake
  • eigen
  • git
  • gcc-fortran
  • pyside2-tools
  • swig
  • qt5-tools
  • shared-mime-info

Also, make sure to check the AUR for any missing packages that are not on the repositories, currently:

  • coin
  • python-pivy
  • med
sudo pacman -S boost-libs curl desktop-file-utils glew hicolor-icon-theme jsoncpp libspnav med opencascade shiboken2 xerces-c pyside2 python-matplotlib python-netcdf4 qt5-svg qt5-webkit qt5-webengine cmake eigen git gcc-fortran pyside2-tools swig qt5-tools shared-mime-info coin python-pivy med

Older and non-conventional distributions

On other distributions, we have very few feedback from users, so it might be harder to find the required packages.

Try first locating the required libraries mentioned in third party libraries in your package manager. Beware that some of them might have a slightly different package name; search for name, but also libname, name-dev, name-devel, and similar. If that is not possible try compiling those libraries yourself.

FreeCAD requires the GNU g++ compiler version equal or above 3.0.0, as FreeCAD is mostly written in C++. During the compilation some Python scripts are executed, so the Python interpreter has to work properly. To avoid any linker problems it is also a good idea to have the library paths in the LD_LIBRARY_PATH variable or in the ld.so.conf file. This is already done in modern Linux distributions, but may need to be set in older ones.

Pivy

Pivy (Python wrappers to Coin3d) is not needed to build FreeCAD or to start it, but it is needed as a runtime dependency by the Draft Workbench. If you are not going to use this workbench, you won't need Pivy. However, do notice that the Draft Workbench is used internally by other workbenches, like Arch and BIM, so Pivy needs to be installed to use these workbenches as well.

By November 2015 the obsolete version of Pivy included with the FreeCAD source code will no longer compile on many systems. This isn't a big problem as normally you should get Pivy from your distribution's package manager; if you cannot find Pivy, you may have to compile it yourself, see Pivy compilation instructions.

Compilare FreeCAD

FreeCAD uses CMake as its main build system, as it's available on all major operating systems. Compiling with CMake is usually very simple and happens in two steps.

  1. CMake checks that every needed program and library is present on your system, and generates a Makefile that is configured for the second step. FreeCAD has several configuration options to choose from, but it comes with sensible defaults. Some alternatives are detailed below.
  2. The compilation itself, which is done with the program make, which generates the FreeCAD executables.

Poiché FreeCAD è un'applicazione pesante, la compilazione può richiedere un po' di tempo (circa 10 minuti su una macchina veloce, 30 minuti, o più, su una lenta)

You can build the code either in or out of the source directory. Out-of-source building is generally the best option.

Costruzione Out-of-source

Se intendete seguire la rapida evoluzione di FreeCAD, convenie costruire in una cartella separata (Out-of-source build). Ogni volta che il codice sorgente viene aggiornato, cMake riconosce intelligentemente i file che sono stati modificati e ricompila solo ciò che è necessario. La costruzione Out-of-source è particolarmente utile quando si utilizza il sistema Git, perché si può facilmente provare altri rami senza confondere il sistema di compilazione. Per costruire out-of-source, è sufficiente creare una cartella di generazione, distinta dalla cartella di origine FreeCAD, e, dalla cartella di compilazione, indirizzare CMake (o se si usa cmake-gui sostituire nel codice seguente "cmake" con "cmake-gui") verso la cartella di origine :

To build out-of-source, simply create a build directory, freecad-build, distinct from your FreeCAD source folder, freecad-source; then from this build directory point cmake to the right source folder. You can use cmake-gui or ccmake instead of cmake in the instructions below as well. Once cmake finishes configuring the environment, use make to start the actual compilation.

mkdir freecad-build
cd freecad-build
cmake ../freecad-source
make -j$(nproc --ignore=2)

The -j option of make controls how many jobs (files) are compiled in parallel. The nproc program prints the number of CPU cores in your system; by using it together with the -j option you can choose to process as many files as you have cores, in order to speed up overall compilation of the program. In the example above, it will use all cores in your system except two; this will keep your computer responsive for other uses while compilation proceeds in the background. The FreeCAD executable will eventually appear in the freecad-build/bin directory. See also Compiling (speeding up) to improve compilation speed.

Costruzione In-source

Se avete dei dubbi, a causa di suoi limiti, non fate una costruzione interna al sorgente, ma create una costruzione out-of-source, come spiegato nella sezione successiva. FreeCAD può essere costruito nel sorgente (in-source), il che significa che tutti i file risultanti dalla compilazione si trovano nella stessa cartella del codice sorgente. Questo va bene per "dare un'occhiata" a FreeCAD, e permette di rimuoverlo facilmente eliminando semplicemente la sua cartella. Quando si prevede di compilarlo spesso, si consiglia invece di fare una costruzione esterna al sorgente (out-of-source) perchè offre maggiori vantaggi. I seguenti comandi compilano FreeCAD:

In-source builds are fine if you want to compile a version of FreeCAD quickly, and don't intend to update the source code often. In this case, you can remove the compiled program and the source just by deleting a single folder.

Change to the source directory, and point cmake to the present directory (denoted by a single point):

cd freecad-source
cmake .
make -j$(nproc --ignore=2)

The FreeCAD executable will then reside in the freecad-source/bin directory.

How to repair your source code directory after accidentally running an in-source build

If you accidentally performed a compilation inside the source code directory, and would like to restore the contents to only the original source code, you can perform the following steps.

> .gitignore
git clean -df
git reset --hard HEAD

The first line clears the .gitignore file. This ensures that the following clean and reset commands will affect everything in the directory and will not ignore items matching the expressions in .gitignore. The second line deletes all files and directories that are not tracked by the git repository; then the last command will reset any changes to tracked files, including the first command which cleared the .gitignore file.

If you do not clear the source directory, subsequent runs of cmake may not capture new options to the system if the code changes.

Configuration

By passing different options to cmake, you can change how FreeCAD is compiled. The syntax is as follows.

cmake -D <var>:<type>=<value> $SOURCE_DIR

Where $SOURCE_DIR is the directory that contains the source code. The <type> may be omitted in most cases. The space after the -D option may also be omitted.

For example, to avoid building the FEM Workbench:

cmake -D BUILD_FEM:BOOL=OFF ../freecad-source
cmake -DBUILD_FEM=OFF ../freecad-source

All possible variables are listed in the CMakeLists.txt file, located in the toplevel freecad-source directory. In this file, search for the word option to get to the variables that can be set, and see their default values.

# ==============================================================================
# =================   All the options for the build process    =================
# ==============================================================================

option(BUILD_FORCE_DIRECTORY "The build directory must be different to the source directory." OFF)
option(BUILD_GUI "Build FreeCAD Gui. Otherwise you have only the command line and the Python import module." ON)
option(FREECAD_USE_EXTERNAL_ZIPIOS "Use system installed zipios++ instead of the bundled." OFF)
option(FREECAD_USE_EXTERNAL_SMESH "Use system installed smesh instead of the bundled." OFF)
...

Alternatively, use the command cmake -LH to list the current configuration, and thus all variables that can be changed. You may also install and use cmake-gui to launch a graphical interface showing all the variables that can be modified. In the next sections we list some of the more relevant options that you may want to use.

Per una Degug build

Create a Debug build to troubleshoot crashes in FreeCAD. Beware that with this build the Sketcher becomes very slow with complex sketches.

cmake -DCMAKE_BUILD_TYPE=Debug ../freecad-source
Oppure per una Release build

Create a Release build to test code that doesn't crash. A Release build will run much faster than a Debug build.

cmake -DCMAKE_BUILD_TYPE=Release ../freecad-source

Building against Python 3 and Qt5

By default, FreeCAD builds for Python 2 and Qt4. Since these two packages are obsolete, it is better to build for Python 3 and Qt5.

In a modern Linux distribution you only need to provide two variables specifying the use of Qt5, and the path to the Python interpreter.

cmake -DBUILD_QT5=ON -DPYTHON_EXECUTABLE=/usr/bin/python3 ../freecad-source

Building for a specific Python version

If the default python executable in your system is a symbolic link to Python 2, cmake will try to configure FreeCAD for this version. You can choose another version of Python by giving the path to a specific executable:

cmake -DPYTHON_EXECUTABLE=/usr/bin/python3 ../freecad-source

If that doesn't work, you may have to define additional variables pointing to the desired Python libraries and include directories:

cmake -DPYTHON_EXECUTABLE=/usr/bin/python3.6 \
    -DPYTHON_INCLUDE_DIR=/usr/include/python3.6m \
    -DPYTHON_LIBRARY=/