1. UNIVERSITÀ DEGLI STUDI DI TRIESTE
FACOLTÀ DI INGEGNERIA
Corso di Laurea Specialistica in Ingegneria Informatica
Sviluppo di un’applicazione di rendering grafico
tridimensionale per l’industria del mobile.
Laureando: Relatore:
Claudio TAMIAZZO Ing. Maurizio FERMEGLIA
Anno Accademico 2007-2008

2. Sommario
1 Introduzione......................................................................................................... 3
2 Analisi ................................................................................................................. 5
2.1 Introduzione ................................................................................................. 5
2.2 Il 3D nell’industria del mobile...................................................................... 6
2.3 Le tre fasce................................................................................................... 7
2.4 Una possibile soluzione: Windows Presentation Foundation......................... 8
2.5 Requisiti di Progetto................................................................................... 10
2.6 Conclusioni ................................................................................................ 11
3 Realizzazione del Progetto ................................................................................. 12
3.1 Introduzione ............................................................................................... 12
3.2 Strumenti Utilizzati .................................................................................... 12
3.2.1 Windows Presentation Foundation (WPF) .......................................... 12
3.2.2 C# (C-Sharp) ...................................................................................... 13
3.2.3 .NET Framework 3.5 .......................................................................... 13
3.2.4 Visual Studio 2008 ............................................................................. 15
3.3 Realizzazione di GeMoWPF ...................................................................... 15
3.3.1 Supporto alla costruzione di mobili..................................................... 15
3.3.1.1 PanelElement3D ............................................................................. 16
3.3.1.2 EntityElement3D ............................................................................ 16
3.3.1.3 FurnitureElement3D ....................................................................... 18
3.3.1.4 Esempi............................................................................................ 18
3.3.2 Il contesto 3D ..................................................................................... 20
3.3.3 Mouse Tracking.................................................................................. 23
3.3.4 Quotatura............................................................................................ 26
3.3.4.1 Quote Stanza .................................................................................. 26
3.3.4.2 Quote Punto-Punto ......................................................................... 28
3.3.4.3 Quota Punto-Entità ......................................................................... 30
3.3.4.4 Quota Entità-Entità ......................................................................... 30
3.3.4.5 Quotatura dinamica......................................................................... 31
3.3.5 Scripting............................................................................................. 32
3.3.5.1 Python e IronPython ....................................................................... 32
3.3.5.2 Implementazione ............................................................................ 33
3.3.5.3 Esempio.......................................................................................... 33
3.3.6 Importazione modelli da 3D Studio Max ............................................ 34
3.3.6.1 Ab3d.Reader3ds ............................................................................. 35
3.3.6.2 Implementazione ............................................................................ 35
3.3.6.3 Esempio di Utilizzo ........................................................................ 36
3.3.7 ScreenShots ........................................................................................ 37
3.3.8 Interfaccia........................................................................................... 38
3.3.8.1 Gestione Camera............................................................................. 38
3.3.8.2 Gestione Entità ............................................................................... 39
3.3.8.3 Gestione Quotatura ......................................................................... 40
3.3.8.4 Scripting e Screenshots ................................................................... 41
3.3.9 Controllo ActiveX .............................................................................. 42
3.3.10 Conclusione........................................................................................ 43
4 Test di Funzionamento....................................................................................... 44
4.1 Introduzione ............................................................................................... 44
4.2 Importazione del Controllo......................................................................... 44
4.3 Interazione con la camera ........................................................................... 45
1

3. 4.4 Scripting..................................................................................................... 46
4.5 Proprietà dei mobili.................................................................................... 47
4.6 Supporto alla Quotatura.............................................................................. 48
4.7 Conclusione ............................................................................................... 49
5 Conclusione ....................................................................................................... 51
2

4. 1 Introduzione
Il seguente lavoro analizza e descrive lo sviluppo di un’applicazione di rendering
grafico tridimensionale per la visualizzazione di prodotti dell’industria del mobile.
Scopo di tale progetto è appunto quello di realizzare un ambiente grafico, nel quale sia
possibile la visualizzazione su schermo di locali arredati, per prevederne l’aspetto
prima che questi vengano effettivamente realizzati.
La necessità di questa soluzione è dovuta all’esigenza, comune in diversi settori
industriali, di avere un riscontro visivo che consenta anticipatamente di analizzare
quello che sarà il prodotto finale. In questo modo è possibile mettere in evidenza, e
quindi evitare, i più grossolani errori di tipo estetico o funzionale che altrimenti
emergerebbero solo a prodotto finito, a costi decisamente più importanti.
Questo tipo di progetto necessita l’integrazione dell’ambiente grafico ad applicazioni
esistenti, tipicamente gestionali. Ricerche principalmente in internet sono state
infruttuose: non esistono soluzioni commerciali standard che prevedano l’integrabilità
totale all’interno di applicazioni esistenti.
Questo lavoro, e l’applicazione che lo accompagna, fanno parte di uno studio di
fattibilità atto a valutare diverse tecnologie grafiche e la loro attitudine a risolvere le
esigenze di progetto. In questo caso specifico si valuteranno le potenzialità della
tecnologia Windows Presentation Foundation presente con il Microsoft .NET
Framework a partire dalla versione 3.0. Per fare ciò, dopo una prima analisi, si passerà
alla realizzazione pratica di un prototipo che implementi le funzionalità richieste.
Infine, a prototipo completato, si valuteranno i risultati ottenuti per determinarne la
bontà in relazione agli obiettivi fissati in partenza.
La realizzazione del progetto si può suddividere in una serie di passi:
Analisi dei requisiti di progetto
•
Studio delle librerie grafiche Windows Presentation Foundation (WPF) con
•
particolare attenzione al loro utilizzo per la realizzazione di applicazioni
grafiche tridimensionali
Realizzazione di un controllo WPF per la visualizzazione in un ambiente 3D di
•
mobili all’interno di una stanza.
3

5. Aggiunta di metodi di interfaccia che consentano l’uso del controllo in
•
applicazioni non WPF.
Aggiunta supporto scripting per l’interazione con l’ambiente grafico.
•
Test e analisi del controllo e delle sue funzionalità
•
Valutazioni finali
•
Il resto del lavoro sarà suddiviso in 4 capitoli principali:
Analisi: In questo capitolo saranno analizzati i requisiti e le specifiche di progetto.
Realizzazione: In questo capitolo sarà descritto il processo realizzativo che ha portato
alla soluzione finale, le tecnologie usate, e gli eventuali problemi riscontrati in corso
d’opera.
Test di Funzionamento: esempi di integrazione del controllo in altre applicazioni e
alcune possibili interazioni per il conseguimento di alcuni scopi funzionali.
Conclusione: Analisi complessiva del progetto e considerazioni finali.
4

6. 2 Analisi
2.1 Introduzione
La grafica tridimensionale rappresenta, per il forte impatto visivo, uno degli argomenti
più affascinanti dell’informatica. La struttura del mondo reale è notoriamente
tridimensionale ed il fatto che la percezione di profondità possa essere riprodotta sullo
schermo di un calcolatore porta innumerevoli benefici in svariati settori. Basti pensare
a come cinema, videogames e progettazione industriale abbiano trovato giovamento
dall’utilizzo della grafica 3D. La cosa che accomuna i tre settori appena citati è proprio
la ricerca del realismo. Ovviamente i livelli di dettaglio e di fedeltà cambiano in base
alle esigenze specifiche, ma di sicuro, la possibilità di ricreare la realtà su calcolatore,
rappresenta la vera spinta alla diffusione della grafica tridimensionale.
Ovviamente vi sono altri settori che fanno uso del 3D per i loro scopi, anche se in
maniera più marginale. L’obiettivo sarebbe quello di estendere l’uso della
tridimensionalità ad un maggior numero di esigenze. Il problema, come sempre, è
dovuto alla complessità nell’uso di queste tecnologie che di conseguenza comporta un
massiccio dispendio di risorse, di tempi e di conseguenza di costi. In questi anni però la
tecnologia continua a fare passi da gigante, e anche nel settore 3D questa evoluzione
continua a produrre nuove soluzioni a costi sempre più accessibili. Grandi aziende
presentano con continuità nuovi tools sempre più completi ed intuitivi per garantire un
miglior supporto alla tridimensionalità.
Scopo di questo progetto è appunto quello di valutare alcune di queste tecnologie al
fine di applicarle a questa problematica dell’industria del mobile. La possibilità
sfruttare il 3D, non solo per motivi tecnici di progettazione, ma soprattutto per scopi
commerciali, nella relazione con il cliente, rappresenta un interessante argomento di
studio.
5

7. 2.2 Il 3D nell’industria del mobile
L’industria del mobile, come altri settori dedicati alla produzione di beni da produzione
industriale, fa ovviamente gran uso delle soluzioni 3D per quanto riguarda la
progettazione e il disegno. Il mercato offre prodotti altamente specializzati per la
realizzazione visuale di mobili. Gli stessi software, ormai, sono efficientemente
attrezzati per supportare anche la produzione e la presentazione e non solo la
progettazione.
Per quanto riguarda puramente il lato commerciale e il rapporto con i clienti, invece, la
tridimensionalità viene sfruttata poco o per nulla. Questo perché, fino ad oggi, investire
in soluzioni grafiche tridimensionali per scopi commerciali richiede un esagerato
dispendio di energie, tempo e danaro rispetto a quelli che sono gli effettivi ritorni
economici. Riutilizzare soluzioni specifiche per la progettazione è poco auspicabile
visto che esse richiedono macchine altamente prestanti e un notevole impegno
ingegneristico per adattarle ai nuovi obiettivi. Se si riuscisse ad ovviare a questi
problemi, grazie all’uso dei più recenti prodotti software, le possibili applicazioni del
3D sarebbero innumerevoli e di notevole interesse.
L’idea di base sarebbe quella di creare un supporto grafico tridimensionale per
applicativi gestionali già massicciamente in uso. Ad esempio, si potrebbe dare supporto
per la creazione di cataloghi 3D o preventivi con corrispondente rappresentazione
grafica. Con la diffusione del web e delle nuove soluzioni informatiche orientate ai
servizi, sarebbe auspicabile la realizzazione di un sistema che offre ai clienti,
direttamente a casa loro, la possibilità di consultare un catalogo 3D dei prodotti offerti.
Quindi, non più una serie statica di fotografie di prodotti, bensì un ambiente grafico
tridimensionale nel quale sia possibile configurare e arredare una stanza con i prodotti
dell’azienda. Questo, ovviamente, è solo un esempio, ma in base al livello di
integrazione che si vuole raggiungere, si può partire da questa idea per produrre
un’innumerevole serie di soluzioni interessanti sempre più dettagliate. Già da una
prima analisi si possono evidenziare i primi vantaggi di una soluzione di questo tipo.
Oltre agli ormai noti benefici derivati dall’uso del 3D che permette una visione di
quello che si andrà a realizzare concretamente, anche il cliente potrebbe risultarne
avvantaggiato, visto che può “customizzare” i prodotti a suo piacimento, nei limiti
permessi. Trattandosi di prodotti a lunga durata, è fondamentale coinvolgere il cliente
6

8. nella scelta di quelle che sono le soluzioni che si adattano di più alle sue esigenze. È in
qualche modo necessario dare l’idea che l’azienda si adatti alle esigenze della clientela
e non che la clientela adatti le proprie esigenze alla luce di ciò che l’azienda offre.
Questa è ovviamente una chimera, ma che va perseguita per far fronte a quelle che
sono le esigenze delle nuove generazioni, e quindi, del mercato.
Per mettere in atto le idee appena esposte è necessario individuare le tecnologie che
possono aiutare a raggiungere questi scopi. Come già detto l’uso di tecnologie grafiche
tridimensionali porta con se notevoli costi di diverso tipo. Occorre tastare il polso allo
stato attuale dell’evoluzione tecnologica per verificare se sia possibile conseguire gli
obiettivi che ci si è preposti. I termini chiave di questa ricerca sono semplicità e
velocità di sviluppo, prestazioni, portabilità e integrazione.
2.3 Le tre fasce
Ad una prima analisi delle possibili tecnologie utilizzabili, è possibile classificare i
prodotti disponibili in tre fasce.
Alta: in questa fascia collochiamo i modellatori solidi, prodotti molto avanzati e
•
complessi. La loro caratteristica principale è un’elevata precisione nel rendering
ed un’elevata programmabilità a discapito di un’alta complessità e difficile
integrabilità. Ad esempio possiamo citare Solid Edge, Solid Works, Think
Design.
Media: in questa fascia collochiamo le librerie grafiche tridimensionali
•
utilizzate per il loro elevato realismo e buon livello di programmabilità, ma allo
stesso tempo la complessità mantiene standard alti. Ad esempio possiamo citare
OpenGL e DirectX.
Bassa: di questa fascia fanno parte quegli strumenti semplici e veloci da
•
programmare, ma che allo stesso tempo comportano una rigidità
nell’implementazione, in cui posizioniamo la tecnologia Windows Presentation
Foundation.
Questa classificazione viene stilata in base al livello di complessità implementativa e di
resa, ma non vuole giudicare la bontà di una soluzione rispetto ad un’altra. Il prodotto
migliore per risolvere un problema rimane sempre quello che si adatta maggiormente
7

9. alla risoluzione di tale specifico problema e non esiste mai il prodotto migliore in
assoluto. La soluzione più adatta, quindi, va ricercata in tutte le fasce in base agli
obiettivi che si vuole raggiungere.
In realtà, le tre fasce sono state presentate al committente di questo lavoro per questioni
di completezza e per cercare un eventuale aggancio con situazioni eventualmente
esistenti presso la loro sede o presso i loro potenziali clienti. Obiettivo specifico è, in
effetti, la valutazione delle Windows Presentation Foundation (WPF), introdotto da
Microsoft con il .NET Framework 3.0. Il target della funzionalità è quello della
realizzazione di applicazioni desktop, tipicamente business. Sono applicazioni in
generale che devono ritornare una resa molto alta facendo, in termini di sviluppo, il
meno possibile. Specificatamente il 3D deve essere molto funzionale, e piacevole, più
che altamente performante o foto realistico. Per questo motivo posizioniamo il prodotto
nel gruppo di fascia bassa. Nella prima presentazione di questo lavoro al committente,
riportando i tre livelli appena presentati, hanno restituito apprezzamento per la visione
di insieme ma non viene dato il modellatore come un possibile aggancio alla loro
soluzione né le librerie come sufficientemente produttive, dato il core business
originale dell’azienda che è quello dei gestionali.
È scopo quindi di questo trattato analizzare e descrivere l’utilizzo di queste librerie per
conseguire gli obiettivi precedentemente delineati.
2.4 Una possibile soluzione: Windows Presentation Foundation
Alla luce degli obiettivi precedentemente descritti, Windows Presentation Foundation
(WPF) potrebbe costituire la soluzione necessaria. WPF è un set di librerie grafiche
introdotte da Microsoft parallelamente all’introduzione del sistema operativo Windows
Vista, nell’ambito del framework .NET. WPF ha permesso di rendere obsolete le
vecchie librerie basate sull’architettura tradizionale di Windows per la gestione
dell’interfaccia grafica (GDI-based) ed ha introdotto un nuovo sistema per la creazione
di applicazioni client. La possibilità di creare grafiche accattivanti e veloce
programmabilità sono le sue doti principali. Inoltre, grazie alle fondamenta che
possiamo trovare nelle librerie DirectX, queste nuove librerie supportano ampiamente
le funzionalità 3D. Ad una prima analisi emergono subito quelli che possono essere i
8

10. vantaggi di WPF alla luce degli obiettivi di progetto. Essendo questa API inclusa nel
.NET Framework dalla versione 3.0, essa ne eredita di conseguenza tutti i pregi.
Quindi, portabilità, integrabilità e programmazione semplice e veloce sono le qualità
più rilevanti. Come è noto, l’ambiente .NET è sviluppato al fine di permettere ai
programmatori di concentrarsi principalmente sul “problem solving” di un progetto.
WPF permette di realizzare applicazioni eseguibili sui comuni browser grazie alla
tecnologia XBAP. Inoltre esiste una versione più leggera e puramente orientata al Web
che passa sotto il nome di Silverlight. Purtroppo questa tecnologia (che al momento del
presente lavoro è arrivata alla versione 3.0) ancora non integra le funzioni 3D di WPF:
rimane però il candidato ideale in un probabile futuro per condividere le funzionalità di
questo lavoro su Web, anche in maniera interoperabile.
I pregi non possono non essere accompagnati da difetti, se li vogliamo intendere in
questo modo. La realizzazione di strumenti sempre più semplici e facili da usare,
comporta un sempre più alto livello di astrazione e questo, inevitabilmente, porta con
sé una sempre maggior rigidità nel suo utilizzo. Più si agisce ad alto livello, e più è
difficile avere il completo controllo di una tecnologia. WPF, rispetto ad altre librerie
tipo DirectX o OpenGL, rappresenta una tecnologia di veloce apprendimento e di facile
utilizzo, ma allo stesso tempo comporta una maggior rigidità di implementazione,
inferiori prestazioni assolute e una non totalità dei risultati ottenibili.
Conseguentemente alle considerazioni fatte, occorre valutare in pratica quali sono le
reali potenzialità di WPF per conseguire i fini di progetto e verificare se i limiti,
quando incontrati, possano essere prevaricanti per gli obiettivi prefissati.
Fortunatamente, al momento non ci sono vincoli di questo tipo. Per questo, dopo
averne superficialmente analizzato le caratteristiche principali, si rivela necessario
realizzare un prototipo che permetta di elaborare delle valutazioni più approfondite.
Occorre, quindi, definire dei requisiti base e tentare di soddisfarli attraverso l’uso di
queste API.
Il resto del trattato descriverà gli obiettivi che si vogliono perseguire e la loro
implementazione pratica.
9

11. 2.5 Requisiti di Progetto
Per valutare la bontà di WPF ai fini di progetto è necessario realizzare un prototipo che
si appoggi su questa tecnologia. Ora verranno elencati i requisiti che occorre soddisfare
affinché il prototipo possa essere preso in considerazione.
L’applicativo deve essere un controllo grafico integrabile nelle interfacce
•
grafiche delle applicazioni gestionali già esistenti. Occorre, quindi, supportare
l’uso del controllo anche in applicazioni non WPF.
Deve essere supportato un ambiente grafico che permetta di creare una stanza
•
nella quale possono essere inseriti mobili di diverso tipo.
Deve essere possibile la creazione di mobili via codice. In modo semplice ed
•
intuitivo deve essere possibile, attraverso l’uso di poche righe di codice, creare
mobili e posizionarli all’interno della stanza.
Deve essere possibile interagire con lo scenario grafico. Ad esempio deve
•
essere possibile togliere, aggiungere, spostare mobili nella stanza nel modo più
semplice ed intuitivo possibile. L’uso di controlli quali mouse e tastiera devono
supportare l’utente nell’interazione con l’ambiente grafico.
Deve essere fornito il supporto per l’importazione di modelli grafici realizzati
•
con il software 3D Studio Max.
Si deve prevedere il supporto all’esecuzione di script. Il controllo può ricevere
•
del testo scritto, in un determinato linguaggio di scripting, ed interpretarlo
eseguendone le direttive.
Nel contesto grafico sono necessari strumenti che permettano misurazioni di
•
distanze tra punti ed entità. Un buon livello di quotatura, anche interattiva, deve
essere fornito.
I punti appena delineati possono essere visti come i requisiti minimi che un applicativo
3D deve soddisfare affinché possa essere considerato la soluzione agli scopi di
progetto.
10

12. 2.6 Conclusioni
A questo punto non resta che procedere con la realizzazione del prototipo. Il resto del
trattato descriverà il processo di implementazione che ha portato allo sviluppo di un
applicativo software conforme ai requisiti delineati. Dopodiché sarà possibile valutare
approfonditamente quanto l’uso delle librerie WPF permetta di raggiungere gli obiettivi
di progetto e con che grado di efficienza.
11

13. 3 Realizzazione del Progetto
3.1 Introduzione
In questo capitolo seguirà una descrizione dettagliata di tutto il lavoro svolto, dalle
tecnologie utilizzate alle tecniche adottate per la realizzazione del progetto. Si
analizzeranno gli eventuali problemi sorti in corso d’opera e le soluzioni per ovviare a
tali problemi.
Inizialmente ci sarà una breve descrizione delle tecnologie utilizzate, poi si passerà
all’analisi del lavoro svolto con descrizione delle classi principali e delle più rilevanti
funzioni implementate.
3.2 Strumenti Utilizzati
Descriveremo ora brevemente quelle che sono le tecnologie adottate per lo svolgimento
del progetto. Il linguaggio di programmazione scelto è C# .NET, mentre l’ambiente di
sviluppo usato è Microsoft® Visual Studio 2008. Per il motore grafico si è deciso di
affidarsi a Windows Presentation Foundation (WPF) il quale dispone di librerie
dedicate per il rendering 3D.
3.2.1 Windows Presentation Foundation (WPF)
Windows Presentation Foundation, nome in codice Avalon, è una libreria di classi del
.NET Framework introdotta con la versione 3.0. Essa è prodotta da Microsoft® per lo
sviluppo di ricche interfacce grafiche in ambienti Windows. WPF, inoltre, fornisce il
supporto per lo sviluppo di applicazioni grafiche in tre dimensioni. Le librerie
specifiche a questo scopo si appoggiano direttamente alle famose librerie grafiche
12

14. DirectX. Questo supporto, viene fornito da WPF al fine di consentire l’uso di grafica
3D in applicazioni client, per permettere ai programmatori la realizzazione di interfacce
sempre più ricche e accattivanti.
La scelta di utilizzare WPF in questo progetto deriva direttamente dalle considerazioni
fatte nel Capitolo 2.
3.2.2 C# (C-Sharp)
C# è un linguaggio specifico per la programmazione ad oggetti, esso può essere
considerato il linguaggio di programmazione per eccellenza del Framework .NET:
diversamente dagli altri linguaggi, come Visual Basic o C++, esso è nato espressamente
per la nuova piattaforma. In questo senso, è significativo il fatto che Microsoft stessa si
sia servita di C# per scrivere gran parte delle librerie di .NET.
La scelta di questo linguaggio è conseguenza diretta della scelta di utilizzare le librerie
WPF e quindi il .NET Framework. Essendo poi C# il linguaggio “principe”
dell’ambiente .NET, la scelta è ricaduta su di esso piuttosto che sugli altri linguaggi
supportati.
3.2.3 .NET Framework 3.5
Il Framework .NET è l’infrastruttura che costituisce la nuova piattaforma creata da
Microsoft® per lo sviluppo di applicazioni component-based, n-tier, per internet, per
l’accesso ai dati, per dispositivi mobili o semplicemente per le classiche applicazioni
desktop. La piattaforma .NET è composta da diverse tecnologie, strettamente
accoppiate fra loro.
Di seguito vedremo un’illustrazione grafica che illustra l’architettura del framework
.NET che, come vediamo, si appoggia direttamente al sistema operativo, nella figura
viene indicato Windows, ma esistono progetti per portare .NET anche su ambienti
diversi.
13

15. Figura 1 Il .NET Framework 3.0
Il componente più importante è sicuramente il Common Language Runtime, CLR, che
gestisce l’esecuzione dei programmi scritti per la piattaforma .NET. Esso si occupa
dell’istanzimento degli oggetti, esegue dei controlli di sicurezza, ne segue tutto il ciclo
di vita, ed al termine di questo esegue anche operazioni di pulizia e liberazione delle
risorse. In .NET ogni programma scritto in un linguaggio supportato dal framework
viene tradotto in un linguaggio intermedio comune, detto CIL (Common Intermediate
Language) o brevemente IL, ed a questo punto esso può essere tradotto ed assemblato
in un eseguibile .NET, specifico per la piattaforma su cui dovrà essere eseguito.
La versione 3.5 del .NET Framework è al momento la più recente rilasciata da
Microsoft®.
La scelta di fare uso delle librerie di questo Framework deriva direttamente dalla scelta
di WPF che ne fa parte dalla versione 3.0 in poi.
14

16. 3.2.4 Visual Studio 2008
Per facilitare la programmazione in C# si è fatto uso dell’ambiente di sviluppo Visual
Studio 2008. Esso consente di sfruttare a pieno le potenzialità del .NET Framework e
facilita e velocizza la programmazione. Con vari strumenti di supporto, Visual Studio,
facilita notevolmente la realizzazione di progetti in ambiente .NET.
3.3 Realizzazione di GeMoWPF
Lo svolgimento del progetto ha portato alla realizzazione di una libreria .NET dal nome
GeMoWPF. Le applicazioni che vogliono farne uso non devono far altro che includere
questa libreria tra le loro risorse e adoperarne le funzionalità esposte. I successivi
paragrafi tratteranno con un buon livello di dettaglio le classi fondamentali che
costituiscono il modello ad oggetti del progetto. Si vedrà quindi, come è stato realizzato
il controllo WPF e quali funzionalità sono state implementate al fine di soddisfare i
requisiti di progetto.
3.3.1 Supporto alla costruzione di mobili
Parte delle classi del modello sono state implementate al fine di consentire la creazione
di mobili attraverso l’uso di poche righe di codice. Partendo da elementi base, quali
pannelli, è possibile costruire, attraverso semplici istruzioni, unità complesse che
descrivono graficamente la struttura di un mobile. Le classi principali coinvolte a
questo scopo sono PanelElement3D, EntityElement3D e FurnitureElement3D. Verrà
ora descritta la struttura di queste classi e la loro applicazione in casi pratici.
15

17. 3.3.1.1 PanelElement3D
PanelElement3D è una classe astratta che delinea quali sono i parametri ed i metodi
fondamentali che consentono la creazione di un pannello. Questa classe implementa i
metodi che permettono di costruire un parallelepipedo rettangolo delle dimensioni
indicate al costruttore. Essa eredita da UIElement3D, classe presente nel .NET
Framework 3.5 che permette di implementare oggetti visuali 3D e di associarvi eventi
come se fossero dei controlli di interfaccia.
Come illustrato in Figura 2, nel modello realizzato vi sono due classi che ereditano da
PanelElement3D: MultiMaterialPanelElement3D e UniformMaterialPanelElement3D.
La differenza sostanziale tra i due tipi di pannelli riguarda i materiali che ne
costituiscono la superficie. UniformMaterialPanelElement3D consente di impostare
solo un tipo di materiale, sia esso una texture o un colore uniforme, mentre
MultiMaterialPanelElement3D consente di impostare un tipo di materiale per ognuna
delle sei facce del pannello.
Figura 2 PanelElement3D e le due classi che derivano da essa.
3.3.1.2 EntityElement3D
EntityElement3D è una classe astratta che definisce le proprietà e i metodi
fondamentali per il rendering di oggetti composti, e quindi, nel caso specifico, di
mobili. Questa classe rappresenta la base per ogni mobile che si vuole includere nello
scenario grafico. Come PanelElement3D, EntityElement3D eredita da UIElement3D,
consentendole, così, di gestire diversi tipi di eventi e di rappresentare modelli composti.
16

18. I due metodi che permettono la creazione di un elemento visuale composto da diversi
sottoelementi sono i seguenti:
protected virtual void Add(PanelElement3D panel,
Vector3D posizione)
protected virtual void Add(EntityElement3D entity,
Vector3D posizione)
Il primo permette di aggiungere alla lista dei figli un elemento di tipo PanelElement3D
in una determinata posizione. Tale posizione ovviamente si riferisce al sistema di
coordinate relative all’EntityElement3D padre. Il secondo metodo permette di
aggiungere alla lista dei figli un elemento di tipo EntityElement3D in modo da
consentire la creazione di strutture complesse. Per far sì, poi, che WPF renderizzi
correttamente l’entità e tutti i suoi figli, EntityElement3D esegue l’override di tre
metodi ereditati:
protected override void OnUpdateModel()
protected override Visual3D GetVisual3DChild(int index)
protected override int Visual3DChildrenCount
Questi tre metodi permettono di comunicare a WPF la struttura visuale del modello
indicando eventuali figli visuali che compongono l’oggetto.
Altri parametri e metodi permettono di conoscere e modificare la posizione e l’angolo
di rotazione, rispetto all’asse verticale centrale, dell’oggetto. Tutto questo per
permettere lo spostamento o la rotazione dei mobili all’interno del contesto visuale.
Figura 3 EntityElement3D e classi derivate
17

19. 3.3.1.3 FurnitureElement3D
Come mostrato in Figura 3, FurnitureElement3D eredita dalla classe astratta
EntityElement3D ed è la classe che rappresenta i mobili presenti nello scenario 3D.
Tutti i mobili presenti nello scenario visuale sono di tipo FurnitureElement3D o
ereditano da esso. Tra i suoi parametri è possibile specificare se il mobile può essere
appeso alle pareti (ad esempio una mensola) o se il mobile è stato selezionato
dall’utente (ad esempio per evidenziare la selezione con colori particolari o altro).
3.3.1.4 Esempi
Per dimostrare l’uso del modello ad oggetti appena descritto sono stati implementati tre
tipi di mobili che consentono di evidenziare le potenzialità del modello:
Cassettiera: Questa classe eredita da FurnitureElement3D e genera un modello
•
che descrive graficamente una cassettiera con quattro cassetti. La costruzione
del modello viene realizzata grazie all’utilizzo dei metodi “Add” ereditati da
EntityElement3D. I cassetti sono a loro volta oggetti che ereditano da
EntityElement3D. In questo modo è stato possibile associare un evento al
doppio click del mouse che fa aprire il cassetto cliccato.
Figura 4 Cassettiera
18

20. Figura 5 Cassettiera dopo doppio click sul secondo cassetto
Armadio: Classe che eredita da FurnitureElement3D e che genera un armadio a
•
tre ante. Alle ante è associato un evento al doppio click del mouse che le fa
aprire con una rotazione di novanta gradi attorno all’asse delle cerniere.
Figura 6 Armadio
Figura 7 Armadio dopo il doppio click sulle ante
19

21. Mensoliera: Classe che eredita da FurnitureElement3D e che genera un insieme
•
di mensole a muro poste una sopra l’altra. Il costruttore, oltre a ricevere le
dimensioni dell’intero mobile, riceve il numero di mensole che compongono il
mobile.
Figura 8 Mensoliera a quattro ripiani
3.3.2 Il contesto 3D
La classe principale di tutto il progetto è GeMoRoomControl. Essa eredita da
UserControl e questo le permette di essere utilizzata all’interno di altri progetti come un
qualsiasi altro controllo di interfaccia grafica presente nel .NET Framework.
All’interno di GeMoRoomControl avviene l’inizializzazione di tutto ciò che serve alla
visualizzazione di uno scenario 3D. L’oggetto principale per il rendering di un
ambiente 3D si chiama Viewport3D. Viewport3D fa parte delle librerie di WPF e si
occupa di tutto ciò che riguarda la visualizzazione di elementi grafici all’interno di un
contesto tridimensionale.
All’interno del costruttore di GeMoRoomControl quindi occorrerà istanziare un oggetto
di tipo Viewport3D
private Viewport3D _viewport = new Viewport3D();
fornire l’illuminazione
_viewport.Children.Add(new ModelVisual3D()
{
Content = new Model3DGroup()
{
Children = {
20

22. new DirectionalLight()
{
Color = Color.FromRgb(192, 192,
192),
Direction = new Vector3D(2, -3, -1)
},
new AmbientLight()
{
Color = Color.FromRgb(96, 96, 96)
}
}
}
}); // una luce direzionale e una ambientale
e la camera di visuale
_cameraController = new CameraController();
_viewport.Camera = _cameraController.Camera;
CameraController è una classe creata all’interno del progetto per fornire una maggiore
padronanza della camera per quanto riguarda eventuali spostamenti, rotazioni, o
ingrandimenti.
Infine il Viewport deve essere incluso nel controllo affinché possa essere visibile a
schermo una volta in esecuzione.
this.Content = _viewport;
A questo punto viene creata la stanza nella quale andranno poi inseriti i mobili che si
vorranno visualizzare. Per creare la stanza è stata implementata una classe astratta di
nome RoomElement3D, che eredita da EntityElement3D (vedere 3.3.1.2).
Successivamente, una classe di nome ARoomElement3D eredita da RoomElement3D
ed implementa i metodi necessari per la realizzazione grafica di una stanza.
Figura 9
21

23. In Figura 9 si può vedere il risultato grafico dell’implementazione di
ARoomElement3D. All’interno della stanza sarà possibile collocare mobili e oggetti. Il
risultato è stato ottenuto attraverso l’utilizzo di elementi di tipo PanelElement3D (vedi
3.3.1.1). In questo prototipo, questo è l’unico modello di stanza utilizzabile, ma in un
lavoro futuro sarà facilmente implementabile un bouquet di stanze fra le quali, un
utente, potrà scegliere quella che si presta meglio ai suoi scopi.
L’aggiunta di mobili all’interno della stanza avviene utilizzando il metodo Add()
esposto da GeMoRoomControl.
public virtual EntityController Add(EntityElement3D entity,
Double PosX, Double PosY, Double PosZ)
Questo metodo inserisce nel Viewport l’EntityElement3D passato come parametro
nella posizione indicata.
Ad esempio, se volessimo inserire una Cassettiera larga un metro, alta un metro e
profonda mezzo metro nel punto (1,0,1) basterebbe questa istruzione.
Add(new Samples.Furnitures.Cassettiera(new Size3D(1, 1, 0.5)),
1, 0, 1);
Il risultato grafico ottenuto sarebbe il seguente.
Figura 10 Cassettiera 1x1x0.5 nel punto (1,0,1)
22

24. 3.3.3 Mouse Tracking
Il modello ad oggetti fornisce diversi metodi che consentono il posizionamento e lo
spostamento di mobili all’interno della stanza. Una volta creato un mobile e collocato
all’interno dello scenario, con poche righe di codice è possibile cambiarne la posizione
e l’orientamento degli assi. Questo, però, risulta comunque poco pratico per un utente
che vuole disporre a suo piacimento gli elementi inseriti. Lo spirito del progetto è
quello di fornire un immediato riscontro grafico a quello che si vuole andare
successivamente a produrre. Conformemente a questo spirito, anche il posizionamento
dei mobili deve risultare immediato e frutto di un’elaborazione visuale. Proprio per
questo si manifesta necessario il supporto allo spostamento di mobili attraverso l’uso di
periferiche hardware di puntamento. Nel caso più comune un utente può, attraverso
l’uso del mouse, spostare i mobili all’interno della stanza per verificarne l’esatto
risultato, sia estetico che funzionale. Ovviamente, questo supporto non è fondamentale,
ma rappresenta una di quelle funzionalità che migliorano pesantemente la fruizione
dell’applicativo.
Per implementare il mouse tracking, WPF fornisce diverse classi che facilitano
notevolmente il lavoro. Come visto precedentemente (3.3.1.2 e 3.3.1.3)
FurnitureElement3D eredita da EntityElement3D che a sua volta eredita da
UIElement3D, classe astratta di WPF. UIElement3D fornisce un immediato supporto
alla gestione degli eventi legati all’interazione con i dispositivi di puntamento. Occorre
quindi, ad ogni mobile che si aggiunge nella stanza, associarvi un “handler” che
gestisca il verificarsi del movimento del mouse sopra di esso.
All’interno del metodo Add() di GeMoRoomControl vi sarà una direttiva di questo
tipo.
entity.MouseMove += new MouseEventHandler(mobile_MouseMove);
Ogni qualvolta l’utente passerà col mouse sopra un mobile, il metodo
mobile_MouseMove() verrà eseguito e trai suoi parametri vi sarà il mobile che ha
generato l’evento.
void mobile_MouseMove(object sender, MouseEventArgs e)
23

25. Successivamente occorre verificare che il tasto sinistro del mouse sia premuto durante
il movimento, onde evitare spostamenti non graditi. Per fare ciò basta verificare i
parametri di tipo MouseEventArgs ricevuti dal metodo.
if (e.MouseDevice.LeftButton == MouseButtonState.Pressed)
{
//eseguo lo spostamento
}
else return; //non faccio niente
Una volta verificato che l’utente stia tentando di spostare un mobile occorre processare
il movimento che il mouse sta producendo. Per fare ciò è necessario ottenere il punto in
cui il mouse si trova al momento della generazione dell’evento. Il punto ottenuto è in
forma bidimensionale e le sue coordinate sono relative al controllo Viewport3D.
Point ptMouse = e.GetPosition(_viewport);
Per spostare graficamente il mobile, posizionando la sua origine nella posizione puntata
dal mouse, bisogna convertire il punto 2D ottenuto, in un punto 3D. Un punto in due
dimensioni, se convertito in tre dimensioni, porta a identificare una retta nello spazio. È
fondamentale trovare quale punto della retta debba corrispondere al punto obiettivo
dello spostamento. Per fare ciò la stanza, in cui i mobili sono inseriti, risulta
fondamentale al fine di una corretta conversione. WPF ci fornisce una classe molto
utile ai nostri scopi: VisualTreeHelper. Questa classe fornisce una serie di metodi
statici che permettono di avere un buon controllo del contesto visuale. Nel caso
specifico, il metodo utile ai nostri scopi è HitTest().
VisualTreeHelper.HitTest(_viewport, HitTestFilter,
HitTestCallBack, new PointHitTestParameters(ptMouse));
Questo metodo “spara” un raggio che parte dal punto indicato e prosegue lungo una
retta. Il punto e la retta vengono definiti attraverso l’elaborazione del punto indicato in
relazione a posizione, orientamento e tipo di proiezione della camera di
visualizzazione. Ogni volta che il raggio incontra un oggetto visuale, viene chiamato il
metodo di callback indicato. Nel nostro caso è stato implementato un metodo di
callback di nome HitTestCallBack(). Questo metodo non fa nulla finché l’HitTest non
24

26. restituisce un pannello che fa parte della stanza, sia esso una parete o parte del
pavimento. Una volta ottenuto un componente della stanza, due variabili globali
tengono memoria del pannello intersecato e del punto di intersezione. Il punto di
intersezione sarà il punto nel quale traslare l’origine degli assi del mobile. Se il
pannello intersecato è una parete e il mobile non può essere appeso ad essa, allora il
punto corrispondente sarà la proiezione del punto ottenuto sul piano y = 0. Se il mobile,
invece, può arrampicarsi, esso verrà spostato sul punto individuato, appoggiato sulla
parete con la schiena su di essa e abbassato nel caso in cui superi l’altezza della stanza.
Prima di applicare la nuova posizione ad un mobile, è necessario eseguire alcuni test
che rendano il tracking più fluido e più realistico. A supporto di ciò sono stati
implementati due metodi.
bool EsceDallaStanza(FurnitureElement3D mobile, ref Transform3D
nuovaTrasformazione)
bool Hit(FurnitureElement3D mobile)
Il primo, EsceDallaStanza(), verifica che il mobile, o parte di esso, non escano dai
limiti della stanza. Questo consente di evitare sgradevoli effetti come, ad esempio,
mobili che attraversano le pareti. Inoltre, il metodo, nel caso in cui il mobile “intenda”
uscire dai confini della stanza, corregge la trasformazione in modo che lo spostamento
risulti coretto. Questa correzione consente un tracking più fluido che evita brusche
interruzioni di movimento.
Il secondo, Hit(), viene invocato al rilascio del tasto sinistro del mouse, cioè quando la
traslazione ha avuto termine. Il metodo verifica che il mobile non si sovrapponga con
un altro mobile presente nella stanza. Se questo si verifica, viene applicata al mobile la
trasformazione di partenza, opportunamente memorizzata all’inizio del tracking.
L’implementazione appena descritta, consente all’utente una fruizione dell’applicativo
ad alto livello di interattività. Collocare mobili, risulta molto più intuitivo dato che,
mentre si interagisce con essi, si ha subito un riscontro visuale che rende l’esperienza
più semplice e veloce.
25

27. 3.3.4 Quotatura
Se si vuole realizzare uno strumento grafico che visualizzi l’arredamento di stanze, è
fondamentale fornire supporto alla misurazione di distanze tra elementi diversi. Senza
un supporto di misurazione, risulta difficile all’utente avere chiare quali siano le
effettive distanze tra gli oggetti. Il collocamento di mobili nella stanza, soprattutto nel
caso in cui si usi il mouse tracking, non può essere soddisfacente con misure “ad
occhio”. Visto che lo scopo finale del progetto è pre-vedere un’implementazione reale,
tutte le distanze devono poter essere valutate prima della realizzazione, altrimenti si
perde parte dei benefici del supporto grafico.
A tale scopo è stato implementato un sistema di quotatura grafico che fornisce diversi
tipi di misurazioni. Le quote introdotte possono essere distinte in due macro-categorie:
le quote relative ai limiti della stanza e le quote indicate dall’utente a seconda delle sue
esigenze di misurazione. La seconda categoria si suddivide in tre sotto categorie: quote
Entità-Entità, quote Punto-Entità e quote Punto-Punto.
3.3.4.1 Quote Stanza
Anche per la quotatura di un mobile relativamente ai limiti della stanza si è fatto ricorso
al metodo HitTest() della classe VisualTreeHelper.
VisualTreeHelper.HitTest(_roomEntity, HitTestFilter,
HitTestCallBack,
new RayHitTestParameters(punto,direzione));
Il punto di origine è il centro geometrico del mobile mentre i vettori che indicano la
direzione del raggio di hit test dipendono dalla posizione del mobile.
Se il mobile giace sul pavimento allora vengono fatti quattro hit test nelle direzioni
degli assi x e z. Per ogni direzione il test viene fatto in tutti e due i versi, negativo e
positivo. Se il mobile giace appeso ad una parete le direzioni dell’hit test sono lungo
l’asse y e lungo l’asse x. L’asse x, però, non è quello globale, ma quello relativo al
mobile. Questo perché l’asse varia a seconda dell’orientazione della parete su cui il
mobile poggia.
L’HitTest() restituirà il punto intersecato e la distanza dalla parete più vicina. Una
semplice sottrazione restituirà la distanza tra la parete e il punto del mobile più vicino
26

28. ad essa. Una volta ottenute le quattro distanze e i punti estremi di ognuna di esse è
possibile generarne una rappresentazione grafica, con relativa quantificazione numerica
espressa in metri.
Figura 11 Quotatura di un mobile giacente sul pavimento
Figura 12 Quotatura di un mobile appeso ad una parete
27

29. Per disegnare le quote, si è fatto ricorso alla libreria Petzold3D realizzata da Charles
Petzold. Questa libreria fornisce diverse classi di supporto a WPF che ne aggiungono
utilissime funzionalità grafiche. Le classi utilizzate sono WireLines e WireText, delle
particolari classi che permettono il rendering di linee e testo all’interno di uno scenario
3D. Come si può notare dalle immagini, le classi, permettono la visualizzazione di linee
quota senza che queste risentano negativamente degli effetti della prospettiva. Lo
spessore delle linee si mantiene uniforme e la loro superficie è sempre rivolta
perpendicolarmente al raggio di visione. Affinché queste linee fossero visibili nel
controllo, qualunque fosse stato il tipo della finestra ospitante (ad esempio Windows
Forms), è risultato necessario effettuare alcune piccole modifiche alla libreria
Petzold3D. Questo perché, la classe WireBase, dalla quale WireLines e WireText
ereditano, prima di effettuare il rendering cerca tra i suoi “genitori” visuali un oggetto
di tipo Window e se non lo trova allora non esegue nessun rendering. In applicazioni
non WPF non esistono oggetti di tipo Window e quindi questo impedirebbe il rendering
delle linee quota nel caso in cui il controllo fosse “ospitato” in tali applicazioni.
Modificando il target della ricerca ad un oggetto di tipo Viewport3D, il problema è
stato facilmente risolto.
3.3.4.2 Quote Punto-Punto
Al fine di permettere all’utente una serie di misurazioni personalizzate, sono state
introdotte delle funzionalità di quotatura che permettono via mouse di indicare i target
di misurazione. Una di queste funzionalità consiste nella possibilità di effettuare delle
misurazioni tra due punti nella stanza. I punti vengono indicati dall’utente con un
semplice click del mouse ed il risultato viene disegnato direttamente all’interno dello
scenario 3D.
Per fare questo è stato implementato un gestore di eventi che rileva la pressione del
tasto sinistro del mouse “sopra” il viewport. Il punto ottenuto viene poi utilizzato come
parametro per un HitTest che restituisce la prima intersezione rilevata. Quindi il punto
selezionato può giacere sulla superficie del pavimento, di una parete, o di un mobile.
Ogni punto individuato viene marcato a schermo in modo da notificare graficamente
l’avvenuta cattura. Ad ogni coppia di punti selezionati viene aggiunta su schermo una
linea quotata congiungente i due punti.
28

30. Figura 13 Distanza tra due punti giacenti su due mobili
Figura 14 Distanza tra due punti giacenti sui pannelli della stanza
29

31. 3.3.4.3 Quota Punto-Entità
Un altro sistema di quotatura introdotto a supporto dell’utente permette il calcolo di
distanze tra un punto arbitrario e un mobile. La distanza rilevata rappresenta la distanza
minima tra i due elementi. Il sistema, al primo click, cattura il punto selezionato, sia
esso su una parete, su un pavimento o sulla superficie di un mobile. Al secondo click,
invece, il sistema cattura il mobile indicato. Ad ogni coppia punto-entità selezionata,
viene visualizzata graficamente la linea quotata che identifica la distanza minima.
Figura 15 Una serie di quote tra l’armadio ed alcuni punti arbitrari
3.3.4.4 Quota Entità-Entità
In un sistema di quotatura, ovviamente, no può mancare uno strumento che permetta il
calcolo della distanza minima tra mobili. È quindi possibile, da parte dell’utente,
indicare delle coppie di entità delle quali se ne vuole conoscere la distanza. Il sistema
memorizza le due entità selezionate via mouse e, dopo alcuni calcoli geometrici,
visualizza graficamente la linea quotata che rappresenta la distanza minima tra di esse.
30

32. Figura 16 Distanze minime tra tre mobili
3.3.4.5 Quotatura dinamica
Il sistema di quotatura appena visto consente all’utente, nel caso in cui lo necessiti, di
effettuare tutte le misurazioni di cui abbisogna. In questo modo il collocamento dei
mobili all’interno della stanza può essere effettuato con maggior precisione. Per
rendere questo supporto ancora più utile si è fatto in modo che le quote disegnate
possano aggiornarsi dinamicamente durante lo spostamento dei mobili. A livello di
implementazione questo non richiede sforzi di rilievo, ma dal lato pratico i benefici
tratti sono notevoli. Durante il tracking di un mobile, quindi, l’utente è assistito
dinamicamente dalla quotatura che, in tempo reale, aggiorna le distanze che
coinvolgono il mobile in movimento. Tutto questo consente un’esperienza di
arredamento veloce, dinamica e precisa.
L’unico problema che potrebbe sorgere da questa implementazione è di tipo
prestazionale. L’aggiornamento in tempo reale di numerose quote può portare a
fastidiosi rallentamenti e a notevoli cali di prestazioni dell’applicativo. Le osservazioni
empiriche effettuate sull’applicativo, dopo numerosi test, hanno comunque portato a
concludere che il sistema risente ben poco di questo peso computazionale.
31

33. 3.3.5 Scripting
Lo scripting fa parte di quelle funzionalità fornite da un’applicazione a supporto degli
utenti di livello “avanzato”. Moltissime soluzioni presenti sul mercato consentono, ai
loro “power users”, la possibilità di creare script di codice da eseguire. Chi ha
dimestichezza con la programmazione può, con poche righe di codice, far eseguire ad
un’applicazione diverse operazioni. Il codice di scripting, infatti, deve avere accesso a
tutto e solo il modello ad oggetti implementato nell’applicazione, nascondendone tutto
il dettaglio implementativo. Il codice deve poter interagire direttamente con le entità
create, quali i mobili e la stanza, non certo con i poligoni e le problematiche di
rendering. Anche in questo prototipo è stato fornito il supporto all’esecuzione di script
Python. Per fare ciò si è fatto ricorso al linguaggio IronPython di Microsoft, che ha il
valore aggiunto di essere totalmente integrabile in altre applicazioni al fine da esserne il
linguaggio di parametrazione.
3.3.5.1 Python e IronPython
Python è un linguaggio di programmazione ad alto livello, interpretato. Esso supporta
pienamente la programmazione ad oggetti e gli viene riconosciuta un’elevata
produttività. Le caratteristiche principali che hanno reso questo linguaggio famoso,
sono proprio la semplicità e la facile leggibilità. Per questi motivi Python viene molto
spesso usato come linguaggio di scripting, anche se i suoi impieghi potrebbero essere
estesi ad applicazioni complete. A supporto di questo linguaggio, e della sua
integrazione con altre tecnologie, sono state distribuite diverse librerie che ne
permettono l’integrazione su diverse piattaforme. Nel caso specifico di progetto, al fine
di utilizzare Python come linguaggio di scripting, risulta necessario un supporto
all’integrazione nell’ambiente .NET. A risposta di questa necessità è stato sviluppato
IronPython. IronPython è un’implementazione del linguaggio di programmazione
Python eseguibile nell’ambiente .NET. Esso consiste in una libreria che fornisce pieno
supporto per la realizzazione di script in Python che fanno uso del modello ad oggetti
del .NET Framework. Ai nostri scopi, l’uso di questa libreria consentirà di creare
porzioni di codice Python in grado di creare mobili e collocarli sullo scenario 3D.
32

34. 3.3.5.2 Implementazione
Per supportare lo scripting in Python è stata implementata una libreria di classi da
includere nel progetto. All’interno della libreria vi è una classe statica,
ISupportScriptingExtender, che espone alcuni metodi per l’esecuzione di script. Le loro
signatures sono le seguenti
public static void ExecuteStream(this ISupportScripting me, Stream
stream)
public static void ExecuteScript(this ISupportScripting me, string
script)
public static void ExecuteFile(this ISupportScripting me, string path)
I tre metodi permettono di eseguire uno script, rispettivamente, da uno stream, da testo
o direttamente da un file. La variabile “me” rappresenta quello che sarà lo “scope”
dell’esecuzione del codice. Nel caso del progetto corrente la variabile “me” passata sarà
un oggetto di tipo GeMoRoomControl (vedere 3.3.2) contenente lo scenario 3D.
3.3.5.3 Esempio
A titolo di esempio vediamo un possibile uso del supporto allo scripting. Lo script da
eseguire è il seguente:
import clr
clr.AddReference(quot;GeMoWPFquot;)
clr.AddReference(quot;PresentationCorequot;)
from GeMoWPF.Samples.Furnitures import Cassettiera
from GeMoWPF.Samples.Furnitures import Mensoliera
from GeMoWPF.Samples.Furnitures import Armadio
from System.Windows.Media.Media3D import *
cs1 = Cassettiera(Size3D(1, 1.3, 0.5))
Me.Add(cs1, 1, 0, 1)
ar1 = Armadio(Size3D(2, 2, 0.7))
33

35. Me.Add(ar1, 0, 0,3)
ar1.ChangeRotation(90);
ar1.ChangePosition(Vector3D (0,0,3))
mn1 = Mensoliera(Size3D(2, 1.5, 0.5), 4)
Me.Add(mn1, 6, 1, 3)
mn1.ChangeRotation(-90);
mn1.ChangePosition(Vector3D (6,1,3));
All’inizio dello script vengono indicate librerie e namespaces a cui si fa riferimento.
Nella seconda parte vengono usati i metodi esposti da GeMoRoomControl per creare e
aggiungere allo scenario dei mobili 3D. La variabile “Me” rappresenta appunto un
riferimento all’oggetto di tipo GeMoRoomControl, passato ai metodi della classe
statica ISupportScriptingExtender (vedere 3.3.5.2). Il risultato grafico finale dopo
l’esecuzione dello script è il seguente.
Figura 17 Risultato dell’esecuzione dello script
3.3.6 Importazione modelli da 3D Studio Max
Scrivere numerose righe di codice per realizzare modelli 3D complessi, comporta
l’impiego di tantissimo tempo, notevoli difficoltà e alla fine potrebbe concludersi con
risultati deludenti. Per questo il mercato offre, ormai da anni, prodotti sempre più
innovativi in grado di supportare al meglio la realizzazione di modelli 3D. Anche nel
34

36. caso del nostro progetto, realizzare modelli di mobili via codice, comporterebbe un
lavoro estremamente lungo e complesso. Si presenta, quindi, la necessita di importare
modelli realizzati con strumenti specifici per il design 3D. Uno di questi strumenti è 3D
Studio Max prodotto da Autodesk. Questo prodotto è largamente utilizzato come
supporto all’industria del gaming e all’industria cinematografica, ma non solo. Visto
che il design tridimensionale di mobili e accessori per l’arredo viene spesso realizzato
con 3D Studio, si è rivelato necessario implementare un supporto che consenta
l’importazione di modelli realizzati con questo strumento.
3.3.6.1 Ab3d.Reader3ds
Cercando in rete, vi sono alcuni strumenti che consentono di importare, nell’ambiente
WPF, modelli grafici realizzati con 3D Studio. Uno di questi è la libreria
Ab3d.Reader3ds prodotta da WPF Graphics. Questa libreria permette di importare da
files 3D Studio (estensione .3ds) modelli tridimensionali e di integrarli in WPF. Grazie
al supporto fornito, oltre ai modelli è possibile importare materiali, luci, camere e
animazioni. Per fare ciò è necessario creare un oggetto Ab3d.Reader3ds ed invocarne il
metodo ReadFile().
Ab3d.Reader3ds modelReader = new Ab3d.Reader3ds();
Model3DGroup model = modelReader.ReadFile(filepath);
Il metodo ReadFile() restituisce un oggetto di tipo Model3DGroup che fa parte delle
classi di WPF. A questo punto il modello potrebbe già essere pronto per il rendering
nello scenario 3D di WPF.
3.3.6.2 Implementazione
Per implementare il porting di modelli 3D Studio nell’ambiente grafico del progetto è
stata creata una classe di nome Furniture3DS. Questa classe eredita da
FurnitureElement3D (vedere 3.3.1.3) consentendole di essere inserita nello scenario
grafico e di essere soggetta a funzionalità quali quotatura (vedere 3.3.4) e tracking
(vedere 3.3.3). Furniture3DS ha un solo costruttore che riceve in input il percorso del
file 3ds contenente il modello, e le dimensioni (in metri) alle quali il modello sarà
35

37. scalato. Una volta invocato il costruttore della classe, quindi, viene caricato il modello
con Ab3d.Reader3ds e poi scalato alle dimensioni indicate.
3.3.6.3 Esempio di Utilizzo
Per caricare modelli 3D Studio nello scenario grafico basta creare degli oggetti
Furniture3DS fornendo il path del file 3ds. Dopodiché, con il metodo Add() di
GeMoRoomControl (vedere 3.3.2), è possibile visualizzare graficamente i modelli 3D
caricati all’interno della stanza, posizionati nel punto specificato.
Furniture3DS luna = new Furniture3DS(@quot;3dsSedieluna.3dsquot;,
new Size3D(0.5, 0.8, 0.4));
Add(luna, 1, 0, 3);
Il codice precedente carica il modello di una sedia, ne scala le dimensioni e lo
posiziona nel punto (1,0,3) della stanza. Il risultato grafico sarà il seguente.
Figura 18 Sedia importata da file 3D Studio Max
Nell’immagine precedente si notano dei difetti di rendering del modello della sedia.
Questo non è dovuto a problemi di importazione o da errori di WPF, bensì è legato ad
una scelta voluta del produttore di Ab3d.Reader3ds. Questo perché la libreria è un
prodotto su licenza a pagamento. L’uso che se ne fa in questo progetto utilizza una
versione trial che limita volutamente il rendering dei triangoli costituenti i modelli.
Starà poi al committente del corrente progetto, decidere se il prodotto si adatta alle sue
esigenze e, quindi, se acquistarne le licenze.
36

38. 3.3.7 ScreenShots
Nel caso si riveli necessario effettuare una stampa dello scenario 3D, è stato
implementato sul prototipo un sistema che consente la realizzazione di “screenshots”.
Nonostante l’elevata portabilità del sistema, in certi casi, può risultare estremamente
scomodo, o addirittura impossibile, l’uso di un calcolatore. Per questo, nel caso in cui
sia necessario condividere i risultati visuali dell’applicazione 3D, scattare delle “foto”
dello scenario può rivelarsi uno strumento molto utile. Il .NET Framework dispone di
strumenti che permettono facilmente di raggiungere questi scopi. Con poche righe di
codice è possibile ottenere un’immagine 2D che riproduce esattamente lo scenario
tridimensionale così come viene visualizzato su schermo. All’interno del prototipo è
stato implementato un metodo di nome GeneraPng() che realizza quanto appena
descritto.
public bool GeneraPng(Stream s)
{
RenderTargetBitmap bitmapImage = new
RenderTargetBitmap((int) this._viewport.ActualWidth,
(int) this._viewport.ActualHeight, 96, 96,
PixelFormats.Pbgra32);
bitmapImage.Render(this._viewport);
BitmapFrame f = BitmapFrame.Create(bitmapImage);
PngBitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(f);
encoder.Save(s);
return true;
}
Il codice appena riportato stampa il viewport di visualizzazione su di uno stream,
passato come parametro. Il formato scelto per la stampa è il png. A titolo di esempio, si
consideri che tutte le immagini presenti in questo trattato sono state realizzate grazie
all’implementazione appena descritta.
37

39. 3.3.8 Interfaccia
Quando si realizza un componente integrabile in altre applicazioni, è importante
implementare una buona struttura di interfaccia. Occorre mettere a disposizione degli
utenti finali (in questo caso altri programmatori) dei metodi ed eventualmente delle
classi che permettano un utilizzo del controllo facile e, allo stesso tempo, completo. Il
controllo deve essere visto come una sorta di scatola nera che espone una serie di
operazioni effettuabili. Queste operazioni devono fornire un utilizzo intuitivo e veloce
del supporto, ma allo stesso tempo permettere di sfruttarne a pieno le potenzialità. In
pratica, occorre mantenere il giusto equilibrio tra facilità d’uso e profondità di
controllo. In Figura 19 si può vedere il diagramma che rappresenta la struttura
dell’interfaccia del controllo. Nei paragrafi seguenti si analizzeranno le
implementazioni dei metodi di interfaccia al fine di raggiungere gli obiettivi appena
descritti.
Figura 19 Interfaccia di GeMoRoomControl
3.3.8.1 Gestione Camera
Diverse funzioni sono state rese disponibili affinché si possa interagire con la camera di
visione. È facilmente immaginabile che, in uno scenario 3D, si manifesti la necessità di
“muoversi” all’interno di esso per visualizzare meglio gli elementi all’interno di esso.
38

40. Ecco brevemente l’elenco delle signatures dei metodi che forniscono questo supporto. I
nomi ne lasciano facilmente intendere le funzionalità.
RotateCameraUp()
•
RotateCameraDown()
•
RotateCameraLeft()
•
RotateCameraRight()
•
ZoomIn();
•
ZoomOut()
•
MoveCameraDown()
•
MoveCameraUp()
•
MoveCameraLeft()
•
MoveCameraRight()
•
RestoreDefaultView()
•
I metodi elencati permettono di ruotare la camera attorno al centro della stanza, di
spostarla, di avvicinarla o di allontanarla. Infine, nel caso in cui ci si perda all’interno
dello scenario 3D, il metodo RestoreDefaultView() riporta la camera nella posizione
originale con l’orientazione originale.
3.3.8.2 Gestione Entità
Ulteriori metodi di interfaccia sono stati implementati per permettere l’interazione con
gli elementi presenti nel contesto 3D. Risulta particolarmente vantaggioso, infatti, poter
consultare o modificare alcune delle proprietà delle singole entità. È utile, quindi,
fornire dei mezzi semplici ed intuitivi che permettano di interagire con le proprietà dei
mobili. A tali scopi, l’applicazione rende disponibili le informazioni relative al mobile
selezionato via mouse. Ogni qualvolta venga selezionato un mobile diverso, il controllo
genera un evento che può essere gestito all’esterno di esso. Un’applicazione che ospita
il nostro prototipo, può ricevere notifica di un’avvenuta selezione e ottenere un oggetto
di tipo EntityController, il quale permette la consultazione o la modifica di alcuni
parametri del mobile selezionato. Nel caso specifico è possibile assegnare un nome,
39

41. modificare la posizione o l’angolo di rotazione dell’elemento. Questo tipo di
implementazione nasce dall’idea che un’applicazione ”ospitante” possa fornire una
griglia grafica di proprietà che descrivano l’elemento selezionato. Man mano che il
soggetto della selezione cambia, la griglia si adegua di conseguenza cambiando il suo
soggetto con l’ultimo selezionato. Partendo da questo punto il bouquet di proprietà può
essere facilmente arricchito in base alle specifiche esigenze. Ad esempio, con questa
implementazione, si potrebbe fornire la possibilità di scelta dei materiali che
costituiscono i mobili tra una gamma di materiali disponibili.
3.3.8.3 Gestione Quotatura
Il supporto alla quotatura (3.3.4) dispone di utili funzionalità per la misurazione di
distanze fra entità all’interno del contesto 3D. L’interfaccia implementata, dispone di
metodi che consentono l’interazione col sistema di quotatura.
Per attivare o disattivare la quotatura dell’oggetto selezionato relativamente alla stanza
(3.3.4.1) sono stati resi pubblici due metodi.
void ShowQuotes()
void HideQuotes()
Come si intuisce dai nomi il primo attiva la quotatura mentre il secondo la disattiva.
Per la quotatura gestita dall’utente (da 3.3.4.2 a 3.3.4.4) invece, è stato introdotto il
concetto di modalità di quotatura. Poiché, in base al tipo di rilevazioni che si intende
effettuare, il sistema gestisce gli eventi del mouse in maniera differente, è necessario
fare in modo che il controllo “sappia” quale tipo di quotatura si vuole ottenere. Sono
state così definite quattro modalità
Nessuna: nessuna quotatura, gli eventi mouse vengono gestiti per effettuare la
•
selezione degli oggetti ed il tracking(3.3.3)
PointToPoint: il controllo sa che ogni due click del mouse deve prendere i
•
rispettivi punti indicati e calcolarne la distanza
PointToEntity: il controllo al primo click rileva un punto, al secondo rileva
•
un’entità e calcola la distanza minima tra i due
EntityToEntity: il controllo gestisce gli eventi mouse per individuare coppie di
•
entità delle quali, poi, deve calcolarne la distanza
Per rendere disponibile questa logica, sono stati implementati due metodi di interfaccia.
40

42. void SetQuotingMode(QuotingMode Modality)
void CancelQuotingMode()
Il primo metodo consente di impostare una modalità di quotatura tra le tre disponibili. Il
parametro passato è un valore numerico che corrisponde ad una modalità. Il secondo
metodo riporta alla modalità normale, dove è possibile spostare e selezionare mobili.
Infine, sono stati implementati altri due metodi che permettono una miglior gestione e
consultazione delle quote.
Quota[] GetQuotes(EntityController Controller)
void RemoveQuote(Quota quota)
Il primo metodo permette di ottenere un array che contiene tutte le quote che
coinvolgono l’entità associata all’EntityController passato come parametro. In questo
modo, l’applicazione che ospita il controllo, può fornire agli utenti maggiori
informazioni riguardo alle quote da loro impostate. Nonostante il rendering delle quote
sullo scenario 3D risulti ben realizzato, potrebbe comunque rivelarsi difficile la lettura
dei valori numerici. Questo perché, in un complesso scenario 3D non tutto è sempre
ottimamente visibile. Per questo, gli oggetti Quota restituiti da GetQuotes() forniscono
una rappresentazione testuale di quelle che sono le entità coinvolte nella misurazione e
il valore numerico della misurazione stessa. Il tutto a favore di una maggior leggibilità
delle informazioni di quotatura. Infine, il metodo RemoveQuote, permette la rimozione
di quote create dall’utente non più necessarie. Tutto questo per evitare il formarsi di
una “selva” intricata di quote che limiterebbero l’utilizzo dell’applicativo.
3.3.8.4 Scripting e Screenshots
Per consentire l’esecuzione di script in linguaggio Python(3.3.5), l’interfaccia espone
un metodo atto specificatamente a tale scopo.
void ExecuteScript(string text);
41

43. Il metodo riceve un elemento di tipo string, nel quale sarà contenuto del testo
contenente del codice scritto in linguaggio Python. L’implementazione retrostante a
questo metodo è ampiamente descritta nel paragrafo 3.3.5.
Per la creazione di screenshots del contesto 3D, invece, viene esposto il metodo
GeneraPng() visto in 3.3.7.
3.3.9 Controllo ActiveX
Come da requisiti, il prototipo realizzato deve integrarsi con un applicativo gestionale
non sviluppato in ambiente .NET. Nel caso specifico, il software che dovrebbe
avvalersi delle funzionalità del controllo 3D, è stato sviluppato per un ambiente Win32.
Al fine di permettere un corretto interfacciamento del controllo si è provveduto ad
integrarlo all’interno di un controllo ActiveX. Con poche righe di codice è stato
possibile fornire ad applicazioni non .NET, le funzionalità offerte dal controllo
GeMoRoomControl.
ElementHost host = new ElementHost();
host.Location = new System.Drawing.Point(0, 0);
host.Dock = System.Windows.Forms.DockStyle.Fill;
this.Controls.Add(host);
_geMoRoomControl = new GeMoRoomControl();
host.Child = _geMoRoomControl;
Le righe di codice appena riportate permettono appunto di includere un controllo WPF
all’interno di un controllo ActiveX. Per i metodi di interfaccia, poi, viene fornita
un’implementazione che si rifà ai metodi descritti in 3.3.8. Il controllo ActiveX non fa
altro che implementare l’interfaccia IGemoRoom (Figura 19), i cui metodi richiamano
quelli definiti all’interno di GeMoRoomControl.
La realizzazione di questo controllo ActiveX, per quanto semplice, ha evidenziato dei
problemi che hanno richiesto alcune modifiche all’intero progetto. Durante dei test di
integrazione sono emersi dei problemi in fase di inizializzazione del controllo. Tutto
questo era legato ad alcune classi del controllo WPF implementate utilizzando il
linguaggio di markup XAML. Per dei problemi di gestione di risorse, l’applicativo
42

44. ospitante evidenziava difficoltà ad importare il prototipo. Questo problema è stato
risolto riscrivendo in C# tutte le classi XAML . Tutte le impostazioni del contesto 3D
descritte in 3.3.3 originariamente erano state implementate in XAML.
3.3.10 Conclusione
Come descritto nei precedenti paragrafi, il lavoro svolto ha portato alla realizzazione di
un prototipo WPF che soddisfa i requisiti richiesti. Grazie a questa implementazione, è
stato così possibile valutare approfonditamente le potenzialità delle API utilizzate.
Dopo una prima fase di studio è stato possibile realizzare un controllo che non ha
deluso le aspettative. Le librerie disponibili si sono dimostrate sufficienti al
conseguimento degli obiettivi. Ora spetta al committente valutare se il prototipo
realizzato può essere ritenuto soddisfacente.
Il seguente capitolo darà una breve dimostrazione pratica di integrazione del controllo
in un’applicazione Windows Forms. Si evidenzieranno i passi necessari per
l’integrazione del controllo all’interno dell’applicativo, e verranno mostrati alcuni
esempi di funzionamento.
43

45. 4 Test di Funzionamento
4.1 Introduzione
Al fine di valutare le potenzialità del prototipo sviluppato e proporne un possibile
utilizzo, è stata implementata una piccola applicazione di test. Il corrente capitolo
analizzerà i passi da effettuare per integrare il controllo grafico all’interno di un altro
applicativo. Successivamente si proporranno alcuni possibili impieghi delle
funzionalità disponibili. L’applicativo realizzato sfrutta le API Windows Forms
presenti nel Microsoft .NET Framework.
4.2 Importazione del Controllo
Il controllo realizzato è contenuto in una libreria a link dinamico dal nome
GeMoWPF.dll. Un applicativo che vuole usufruirne deve importarla tra le sue risorse e
dichiarare l’uso del namespace nel quale classi e metodi sono esposti. La direttiva C#
per l’importazione del namespace è la seguente
using GeMoWPF;
Dopodiché sarà possibile istanziare un oggetto ActiveX da inserire all’interno
dell’interfaccia grafica.
private GeMoWPF.GeMoRoomActiveXControl geMoRoomViewerActiveX1;
this.geMoRoomViewerActiveX1 =
new GeMoWPF.GeMoRoomActiveXControl();
this.Controls.Add(this.geMoRoomViewerActiveX1);
44

46. Con poche righe di codice è già possibile visualizzare il controllo all’interno della
finestra Windows Forms. Lanciando il programma test il risultato grafico sarà il
seguente.
Figura 20 Controllo ActiveX visualizzato su di una Form
Le precedenti righe di codice e l’illustrazione dimostrano come, l’implementazione di
un controllo ActiveX, permetta l’integrazione del prototipo all’interno di applicativi
non WPF. Il tutto viene fatto con poche righe di codice e senza difficoltà.
4.3 Interazione con la camera
Per sfruttare le funzionalità relative alla navigazione all’interno dello scenario, è stata
implementata una barra strumenti. I bottoni di questa barra, permettono di agire sulla
camera di visuale attraverso i metodi descritti in 3.3.8.1. L’applicativo di test, quindi,
esporrà una serie di comandi che permettono l’uso di queste funzionalità.
45

47. Figura 21 Toolbar per il movimento della camera
La figura 18 mostra l’implementazione grafica della barra strumenti. I comandi relativi
ai singoli bottoni sono rispettivamente per avvicinamento, allontanamento, quattro tasti
per lo spostamento e infine un bottone per riportare la camera nella configurazione di
partenza. La rotazione della camera attorno alla stanza, invece, è gestita dalla pressione
dei tasti “freccia” direttamente da tastiera. L’implementazione a codice di ogni singolo
bottone si limita ad una singola chiamata al rispettivo metodo esposto dal controllo
ActiveX.
4.4 Scripting
Per fornire supporto allo scripting, l’applicativo di test è stato dotato di una casella che
permette l’immissione di testo. In questo modo l’utente può interagire con il controllo
attraverso l’immissione di frammenti di codice. Attraverso questo strumento sarà
quindi possibile l’aggiunta di elementi al contesto 3D. Un bottone permetterà poi
l’invio del testo al controllo che procederà con l’elaborazione dello script come
descritto in 3.3.6.
Figura 22 Casella di testo per l’esecuzione di script in Python
46

48. 4.5 Proprietà dei mobili
Grazie al supporto fornito per l’interazione con le entità (vedere 3.3.8.2), è possibile
consentire all’utente l’interazione con i mobili e le loro proprietà. A tale scopo si è
utilizzato il controllo PropertyGrid, presente nelle API .NET. Questo controllo rende
graficamente visibili le proprietà di un oggetto consentendone eventualmente la
modifica. L’applicativo di test, ogniqualvolta cambi l’elemento selezionato nel contesto
3D, riceve la notifica dell’avvenuto cambiamento e imposta il nuovo soggetto del
PropertyGrid. Tale soggetto sarà l’oggetto EntityController presente tra gli argomenti
dell’evento, il quale (come visto in 3.3.8.2) sarà associato al mobile selezionato.
Vediamo il codice che aiuta a rendere più chiaro il concetto.
this.geMoRoomViewerActiveX1 .ObjectSelected += new
SelectedEntityControllerEventHandler(Form1_ObjectSelected)
L’applicativo di test aggiunge un gestore per l’evento di cambio selezione. Questo
gestore ovviamente è implementato all’interno dell’applicativo stesso.
void Form1_ObjectSelected(object sender,
SelectedEntityControllerEventArgs e)
{
this.propertyGrid1.SelectedObject = e.EntityController;
}
L’implementazione del gestore non fa altro che prendere tra gli argomenti
l’EntityController relativo al mobile scelto e impostarlo come “soggetto” del
PropertyGrid. Il risultato sarà il seguente.
Figura 23 PropertyGrid con le proprietà di un armadio
47

49. 4.6 Supporto alla Quotatura
Per permettere l’interazione con gli strumenti di quotatura sono stati implementati degli
appositi controlli grafici. Questi controlli fanno ovviamente uso dei metodi esposti dal
controllo 3D descritti in 3.3.8.3.
Un tasto a due stadi permette all’utente se visualizzare o no le quote stanza, mentre un
controllo a discesa permette di selezionare le modalità di quotatura.
Figura 24 Tasto di attivazione quote stanza e menù a tendina per la modalità di quotatura
Per la gestione delle quote utente, un controllo di tipo lista è stato implementato.
Ogniqualvolta cambia il mobile selezionato, la lista si popola con le quote relative a
quello stesso mobile. Il metodo GetQuotes() esposto dal controllo WPF (vedere 3.3.8.3)
permette di ottenere le quote che coinvolgono il mobile selezionato. Gli oggetti Quota
restituiti forniscono una descrizione testuale delle loro proprietà. Questo a vantaggio di
una miglior lettura.
Figura 25 Lista delle quote utente di un armadio
In Figura 25 è possibile visualizzare la lista delle quote indicate dall’utente che
coinvolgono un armadio. Tramite la selezione di una quota nella lista, è poi possibile
richiamare il metodo Highlight() della classe Quota, che evidenzia graficamente la
quota selezionata cambiandone il colore. Questo si rivela molto utile in presenza di
molte quote difficili da identificare graficamente.
48

50. Figura 26
Figura 27
Le figure 26 e 27 mostrano la selezione di una quota sulla lista e conseguente
evidenziazione grafica.
Per eliminare quote ritenute non più utili all’utente, la pressione del tasto “canc” invita
l’applicazione test ad invocare il metodo di interfaccia RemoveQuote() che elimina la
quota selezionata.
4.7 Conclusione
La realizzazione di questo applicativo di test ha portato alla verifica del funzionamento
del prototipo realizzato. Come descritto nei paragrafi precedenti, poche righe di codice
hanno permesso l’integrazione del controllo all’interno di un applicativo Windows
Forms. In pochi passi è stato possibile realizzare uno strumento che sfrutta
49

51. egregiamente il supporto 3D. È evidente che, sia il controllo che l’applicativo ospitante,
necessitano di ulteriori modifiche per definirsi completi. Questo però va oltre gli
obiettivi di progetto. Lo scopo non è quello di realizzare un applicativo finito, ma di
testare le potenzialità della tecnologia WPF, al fine di fornire supporto 3D ai software
gestionali utilizzati nell’industria del mobile.
Un’immagine conclusiva mostra l’interfaccia dell’applicazione test realizzata.
Figura 28 L’interfaccia dell’applicativo di test.
50

52. 5 Conclusione
Facendo un’analisi conclusiva del lavoro svolto, si può dire che l’obiettivo di progetto è
stato raggiunto. Il lavoro ha portato alla realizzazione di un prototipo di un controllo
grafico tridimensionale per il rendering di prodotti dell’industria del mobile. In questo
modo si è dimostrato che la tecnologia Windows Presentation Foundation può essere
presa in considerazione per la realizzazione del progetto. Sta ora al committente
valutare la bontà del risultato in relazione ai propri scopi.
La progettazione ha portato alla realizzazione di un applicativo costituito da circa 6000
righe di codice C# e 25 classi. Inoltre, per testare il prototipo, è stato realizzato in
piccolo applicativo test costituito da circa 1000 righe di codice.
Si può quindi concludere che i passi descritti nell’introduzione sono stati tutti
pienamente soddisfatti. Nel corso della programmazione non sono emersi grossi
problemi se non i classici problemi che si incontrano in qualsiasi tipo di lavoro
informatico. Questo dimostra, una volta in più, che la soluzione tecnologica WPF
merita di essere presa in considerazione ai fini progettuali.
Il giudizio personale sull’esperienza di questo lavoro è sicuramente positivo. Grazie a
questo progetto ho incamerato nuove conoscenze ed ho approfittato per aggiungere al
mio bagaglio una nuova interessante tecnologia. I vari problemi riscontrati in corso
d’opera hanno pesantemente contribuito alla mia formazione. Come nella vita
quotidiana, gli errori fatti sono sicuramente la parte più importante dell’esperienza,
poiché da essi si trae il maggior insegnamento.
Il futuro di questo progetto è strettamente legato alle decisioni del committente. Nel
caso questi decidesse di adottare il prototipo per i propri scopi sarebbe necessario
renderlo un vero e proprio applicativo. Occorrerebbe quindi prestare maggior
attenzione all’affidabilità e alla funzionalità. Il prototipo di per sé è già utilizzabile, ma
ovviamente manca di quel raffinamento che gli permetta di considerarsi un prodotto
finito. Successivamente, innumerevoli implementazioni possono essere fatte al fine di
estendere le funzionalità dell’applicativo. Considerando le potenzialità dell’ambiente
.NET, la lista delle possibili evoluzioni del progetto è assai lunga e svariata.
51

53. BIBLIOGRAFIA
1. WPF:
“Applications= Code + Markup” di Charles Petzold
“3D Programming for Windows” di Charles Petzold
http://www.charlespetzold.com/blog/blog.xml: Blog di Charles Petzold
2. API .NET
http://msdn.microsoft.com: Microsoft Developer Network
3. Geometria a supporto della grafica 3D
http://www.gamasutra.com/: Sito dedicato al gaming 3D.
http://www.geometrictools.com/: Sito dedicato alla geometria 3D.
“3D Math Primer for Graphics and Game Development” di Fletcher Dunn e
Ian Parberry
4. IronPython
http://ironpython.codeplex.com/
5. Porting da 3D Studio a WPF
http://www.wpf-graphics.com/Reader3ds.aspx
52