Tesi Tamiazzo09

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

1

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

2

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

5 Conclusione ....................................................................................................... 51

3

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.

4

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

5

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.

6

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

7

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

8

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

9

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.

10

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.

11

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.

12

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

13

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.

14

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.

15

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.

16

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.

17

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

18

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

19

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

20

• 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 = {

21

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

22

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)

23

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)

24

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

25

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.

26

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

27

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

28

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.

29

Figura 13 Distanza tra due punti giacenti su due mobili

Figura 14 Distanza tra due punti giacenti sui pannelli della stanza

30

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.

31

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.

32

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.

33

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

clr.AddReference("PresentationCore")

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

34

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

35

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à

36

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(@"3ds\Sedie\luna.3ds",

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.

37

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.

38

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.

39

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,

40

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.

41

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

42

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

43

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.

44

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

45

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

46

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

47

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

48

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.

49

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

50

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.

51

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.

52

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

Tesi Tamiazzo09

Technology

Transcript of Tesi Tamiazzo09