Il Blog di IngegneriaLibera

Questa pagina è in sola lettura. Puoi visualizzare il sorgente, ma non puoi modificarlo. Contatta l'amministratore se pensi che ci sia un errore.
====== Tutorial FreeCAD #5 - Creiamo oggetti personalizzati ======

Abbiamo visto nel [[tutorial_freecad:tutorial_04|precedente tutorial]] le potenzialità di personalizzazione offerte dagli script python all'interno di FreeCAD. Tale strumento potrebbe però trovare un limite nella necessità di ripetere tutta la sequenza di comandi python ogni qualvota desideriamo modificare l'oggetto che abbiamo creato.

E' possibile superare questo limite creando oggetti personalizzati le cue dimensioni caratteristiche, analogamente a quanto avviene per gli oggetti già disponibili in FreeCAD, possono essere modificate nella finestra di dialogo delle proprietà.

===== Impostazione generale =====

Gli oggetti personalizzati sono delle classi. Per quelli di voi non avvezzi alla programmazione [[http://it.wikipedia.org/wiki/Programmazione_orientata_agli_oggetti|orientata agli oggetti]], diciamo che le classi sono dei contenitori di variabili e funzioni. Ovviamente python supporta anche il paradigma di programmazione ad oggetti.

~~READMORE~~

Contrariamente a quanto ci si potrebbe aspettare, la procedura di creazione di oggetti "su misura" non prevede la creazione di una classe derivata. Si creano invece due classi: una si occuperà di definire la geometria dell'oggetto, l'altra la sua visualizzazione.

In questo tutorial creeremo un oggetto personalizzabile a partire dal [[tutorial_freecad:tutorial_04|precedente tutorial]]. In un file testo che supponiamo di chiamare customobject.py definiremo pertanto le due classi: CustomObject e ViewProviderCustomObject.

===== Moduli =====

Per lo svolgimento di questo tutorial utilizzeremo, oltre ai moduli FreeCAD e FreeCADGui, il modulo Part. All'inizio del file dobbiamo pertanto richiamare i moduli da importare

  import FreeCAD
  from FreeCAD import Base
  import Part

===== CutomObject: definizione dell'oggetto =====

La prima classe contiene la definizione dell'oggetto vero e proprio. Nel suo costruttore dobbiamo definire le proprietà che comparranno nella finestra di dialogo proprietà, nel nostro caso b, h ed l, che quindi vogliamo cambiare interattivamente. Nel nostro caso abbiamo tre variabili: b, h e l.

  class CustomObject:
      def __init__(self, obj):
          obj.addProperty("App::PropertyLength","b","CustomObject","Base").b=500.0
          obj.addProperty("App::PropertyLength","h","CustomObject", "Altezza").h=100.0
          obj.addProperty("App::PropertyLength","l","CustomObject", "Altezza").l=400.0
          obj.Proxy = self

Poniamo l'attenzione sull'ultima linea di codice. Nella creazione di CustomObject, è necessario dare come parametro un oggetto Part::FeaturePython, nel nostro codice obj. L'attributo Proxy della classe deve puntare all'oggetto personalizzato che stiamo creando.

E' necessario definire la tipologia di proprietà che stiamo definendo. Nel nostro caso abbiamo definito le proprietà definite sono delle lunghezze cui FreeCAD associa il tipo //App::PropertyLength//. Per sapere quali sono le proprietà disponibili in FreeCAD digitiamo nella shell python:

  obj=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box")
  obj.supportedProperties()

Otteniamo così l'elenco completo 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
  ...

Passiamo ora a disegnare l'oggetto con i comandi già visti al precedente tutorial, che andremo a ricopiare nel metodo execute

    def execute(self, fp):
        Vert1 = Base.Vector(0,0,0)
        Vert2 = Base.Vector(fp.b,0,0)
        Vert3 = Base.Vector(fp.b,fp.h,0)
        Vert4 = Base.Vector(0,fp.h,0)
        
        Line1 = Part.Line(Vert1,Vert2)
        VertC1 = Base.Vector(fp.b+fp.h/2,fp.h/2,0)
        Arc1 = Part.Arc(Vert2,VertC1,Vert3)
        Line2 = Part.Line(Vert3,Vert4)
        VertC2 = Base.Vector(-fp.h/2,fp.h/2,0)
        Arc2 = Part.Arc(Vert4,VertC2,Vert1)
        
        Shape1 = Part.Shape([Line1,Arc1,Line2,Arc2])
        
        Wire1 = Part.Wire(Shape1.Edges)
        Face1 = Part.Face(Wire1)
        
        Solid1 = Face1.extrude(Base.Vector(0,0,fp.l))
        fp.Shape = Solid1

Abbiamo sostituito alla variabili b, h, l gli attributi fp.b, fp.h, fp.l.

===== ViewProviderCustomObject: visualizzazione dell'oggetto =====

La classe ViewProviderCustomObject si occupa della visualizzazione del nostro oggetto. 

  class ViewProviderCustomObject:
      def __init__(self, obj):
          obj.Proxy = self

Vediamo che anche questa classe riceve come primo parametro un oggetto, che questa volta è di tipo Gui::ViewProviderPythonFeature. Tipicamente tale valore sarà pari all'attributo ViewObject dell'oggetto FeaturePython che abbiamo creato al paragrafo precedente.

Non avendo particolari esigenze di visualizzazione, ci basta fermarci al costruttore della classe. In questo caso FreeCAD utilizzerà per la visualizzazione l'oggetto Shape definito nella classe CustomObject del paragrafo precedente.

Volendo FreeCAD offre la possibilità di personalizzare la visualizzazione disegnando l'oggetto con la libreria [[http://www.freecadweb.org/wiki/index.php?title=Pivy|pivy]], che ci permette di accedere da python alla libreria [[https://bitbucket.org/Coin3D/coin/wiki/Home|Coin3D]]. In questo modo è possibile avere pieno controllo su quanto viene visualizzato.

Qualora intendessimo avvalerci di tale possibilità, sarà necessario definire il metodo attach(self, obj), nel quale creiamo gli oggetti necessari per il nostro disegno (prendendoli dalla libreria pivy), ed il metodo , updateData(self, fp, prop), che li modifica in caso di variazione delle proprietà. L'implementazione di tali funzionalità richiede necessariamente capacità di programmazione avanzata.

===== Il nostro oggetto all'opera =====

Una volta scritto il file customobject.py dobbiamo collocarlo in una posizione in cui sia raggiungibile dall'interprete python. Se intendiamo usare questo oggetto all'interno dell'ambiente Part, possiamo ad esempio copiarlo nella directory Mod/Part presente nella struttura dei file di FreeCAD. In alternativa possiamo collocarlo in una qualsiasi directory di nostra scelta il cui indirizzo sarà copiato nella variabile PYTHONPATH. Se lavoriamo in ambiente linux, l'approccio più corretto a mio avviso è copiare i file nella directory "Percorso macro" che abbiamo impostato nelle preferenze (per accedere all'impostazione seguite il percorso Modifica->Preferenze->Generale->Macro).

A questo punto lanciamo FreeCAD, creiamo un nuovo modello ed entriamo nell'ambiente Part. Verificato di aver collocato il file customobject.py di modo d renderlo raggiungibile da python, ne importiamo il contenuto con i comandi

  import customobject
  from customobject import *

di modo da poter richiamare direttamente i comandi contenuti all'interno. Creiamo quindi l'oggetto personalizzato con i comandi

    a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","CustomObject")
    CustomObject(a)
    ViewProviderCustomObject(a.ViewObject)
    FreeCAD.ActiveDocument.recompute()

Per nostra comodità possiamo creare una funzione personalizzata

  def makeCustomObject():
      a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","CustomObject")
      CustomObject(a)
      ViewProviderCustomObject(a.ViewObject)
      FreeCAD.ActiveDocument.recompute()


da inserire nel file customobject.py.

A questo punto, dopo aver ricaricato il modulo con

  reload( customobject )
  from customobject import *

possiamo creare più semplicemente l'oggetto con il comando

  makeCustomObject()


{{ :tutorial_freecad:tut05-01_oggetto_personalizzato.png?600 |Cosa vedremo a video caricando il nostro script}}

Il codice python visto nel tutorial è disponibile all'indirizzo [[http://ingegnerialibera.altervista.org/blog-file/freecad-tut05/customobject.py|ingegnerialibera.altervista.org/blog-file/freecad-tut05/customobject.py]].

Il corrispondente file FCStd è disponibile al link [[http://ingegnerialibera.altervista.org/blog-file/freecad-tut05/tut05.FCStd|ingegnerialibera.altervista.org/blog-file/freecad-tut05/tut05.FCStd]].

===== E quindi? =====

Passiamo ora ad analizzare i vantaggi dell'impiego degli oggetti personalizzabili. Selezionando l'oggetto nella finestra "Visualizzazione Struttura", nella finestra "Proprietà" attiviamo la scheda dati

{{ :tutorial_freecad:tut05-02_modifica_proprieta.png?600 |Le proprietà dell'oggetto creato evidenziato nella scheda dati}}

Nell'immagine sono evidenziate le tre proprietà che abbiamo creato nel costruttore della classe CustomObject. Cambiando i relativi valori, automaticamente il modello si aggiorna

{{ :tutorial_freecad:tut05-03_oggetto_modificato.png?600 |Abbiamo modificato le proprietà dell'oggetto appena creato}}

===== Caveat =====

Distribuendo file contenenti oggetti personalizzati è necessario seguire un'accortezza: **oltre al file FCStd è necessario distribuire gli script python in cui sono definiti gli oggetti personalizzati**!

===== Per andare oltre... =====

Applicando quanto visto finora è possibile creare oggetti personalizzati di varia tipologia. Vi allego alcuni esempi:

  * [[http://ingegnerialibera.altervista.org/blog-file/freecad-tut05/squaretube.py|squaretube.py]], per creare tubi quadrati

{{ :tutorial_freecad:tut05-04_tubo-quadro.png?300 |Tubo quadro}}

  * [[http://ingegnerialibera.altervista.org/blog-file/freecad-tut05/uprofile.py|uprofile.py]] per creare profili piegati a freddo profilo a U

{{ :tutorial_freecad:tut05-05_profilo-u.png?300 |Profilo ad U}}

  * [[http://ingegnerialibera.altervista.org/blog-file/freecad-tut05/bolt.py|bolt.py]], per creare bulloni

{{ :tutorial_freecad:tut05-06_bullone.png?300 |Bullone}}

  * [[http://ingegnerialibera.altervista.org/blog-file/freecad-tut05/rectbeam.py|rectbeam.py]], per creare travi a sezione rettangolare tagliate alle estremità secondo angoli dati

{{ :tutorial_freecad:tut05-07_rectbeam.png?300 |Trave a sezione rettangolare}}

===== Link utili =====

Le pagine del wiki di FreeCAD che toccano gli argomenti visti nel tutorial:

  * [[http://www.freecadweb.org/wiki/index.php?title=Scripted_objects]]
  * [[http://www.freecadweb.org/wiki/index.php?title=Scenegraph]]
  * [[http://www.freecadweb.org/wiki/index.php?title=Pivy]]

===== Potrebbero interessarti anche... =====

Un elenco degli altri tutorial disponibili su FreeCAD

<blog related>
</blog>
Il Blog di IngegneriaLibera

Strumenti Utente

Strumenti Sito

Strumenti Pagina
