Strumenti Utente



tutorial_freecad:tutorial_05

Tutorial FreeCAD #5 - Creiamo oggetti personalizzati

Abbiamo visto nel 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 orientata agli oggetti, diciamo che le classi sono dei contenitori di variabili e funzioni. Ovviamente python supporta anche il paradigma di programmazione ad oggetti.

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 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 pivy, che ci permette di accedere da python alla libreria 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()

Cosa vedremo a video caricando il nostro script

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

Il corrispondente file FCStd è disponibile al link 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

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

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:

Tubo quadro

  • uprofile.py per creare profili piegati a freddo profilo a U

Profilo ad U

Bullone

  • rectbeam.py, per creare travi a sezione rettangolare tagliate alle estremità secondo angoli dati

Trave a sezione rettangolare

Potrebbero interessarti anche...

Comments


tutorial_freecad/tutorial_05.txt · Ultima modifica: 2016/01/13 18:20 da mickele

Facebook Twitter Google+ Digg Reddit LinkedIn StumbleUpon Email