Cominciamo col ricapitolare alcuni degli aspetti relativi al rapporto strutturale dell'informatica con l'architettura, rapporto che è stato definito già come tale in questo corso; possiamo anche osservare come esso si articoli su diversi livelli quali quello culturale,

sociologico,

filosofico,

e... naturalmente estetico!

Possiamo ancora individuarne molti, poichè è un vero e proprio rapporto strutturale, che coinvolge quindi questioni molto profonde, quali ad esempio quelle dentitarie,

e condiziona l'architettura in maniera permanente...

Allora,

Riguardiamo infatti questo link a cura del Prof. A. Saggio: Informazione Materia Prima dell'Architettura

e facciamo le nostre considerazioni riallacciandoci ad alcune delle conquiste che avrete cominciato a fare nel corso....;

Ci interessano però alcuni aspetti evidenti di tale rapporto che ci portano su un piano progettuale; tutto ciò non tanto per costruire, alimentare e cristallizzare, una presunta cultura del progetto frutto della Rivoluzione Informatica, (il che probabilmente corrisponderebbe al voler imbrigliare in una struttura burocratica un fenomeno ancora così vitale), quanto per costruire rispetto al fenomeno architettonico, un pensiero nel quale l'informatica e la sua strumentazione siano centrali.

Perchè lo Strumento è la chiave di un ragionamento finalizzato alla costruzione (e decostruzione) del progetto architettonico,quale fenomeno basato su meccanismi che ne determinano la sostanza? Riferiamoci come base di questo ragionamento ancora ad una Conferenza del Prof. Saggio >>>>qui

E poi per chi volesse il testo in italiano di questo pensiero, lo si può trovare >>>>qui

Più che dello strumento, ampiamente trattato dal Prof. Saggio al link precedente, vorrei indicare come spunto su cui riflettere a partire da quel pensiero, la condizione di strumentazione, ovvero una dimensione cognitiva, nella quale una certa strumentazione, intesa come un insieme di apparati anche composti di strumenti diversi, assuma una condizione cruciale all'interno dell'operare umano.

B) Permettono di operare con quelle dimensioni....

rappresentarle

riprodurle

ovvero manipolarle >>>>>>>>>>>

notiamo però:

Lo strumento rivela delle dimensioni ma l'osservatore ovvero chi manipola lo strumento, fa comunque parte della scena!

osservazioni...

b) Un’altra osservazione che faremo sin da ora e che progressivamente amplieremo durante il corso, è che gli atti, le azioni che eseguiremo con la forma e per la forma, sia in fase di progettazione che nella realtà di un’opera di architettura, costituiscono la condizione e le promesse di quello che definiamo da un lato come produzione del progetto e dall’altro il suo programma d’uso.

Ma.....................................................................................................Cos’è lo script?!?

Tecnicamente uno script è una serie di istruzioni. Il computer esegue le istruzioni, quindi restituisce dei dati, o dei valori quali potrebbero essere numeri, stringhe, elenchi, o ancora altri tipi di dati.

Alcune osservazioni:

Coerentemente alla definizione del Prof. Saggio, sull'informazione, osserviamo che il computer restituisce delle informazioni; le operazioni che noi facciamo quindi sono nel senso più letterale del termine, applicazioni continue di convenzioni a dati.

Possiamo ancora definire lo script in varie maniere; nel suo significato generale indica qualcosa che viene scritto per eseguire una serie di compiti (task). In generale la stesura di uno script avviene attraverso delle righe riconosciute dall’applicazione nell’ambito di un certo linguaggio.Fra gli script comunemente utilizzati nelle applicazioni informatiche troviamo, per citare quelli più comuni:

javascript; (applicazioni web, processing, telefonia mobile, ecc.)
actionscript (Flash, videogaming, ecc.)
maxscript (3dsmax)
rhinoscript (Rhino)

..................................

Alcune osservazioni di base, utili per orientarci in questo argomento:

Non ci riferiamo certo alla programmazione quando ci occupiamo di Script. Sebbene alcuni livelli operativi di programmabilità è fin troppo ovvio che ci siano, la programmazione è qualcosa di più complesso e dagli obiettivi ancora più generali.

Quando un programmatore scrive un programma, 'insegna' letteralmente alla macchina a fare un compito. Posso scrivere un programma per disegnare, uno per scrivere e-o per impaginare, posso scriverne un altro per fare musica. I Programmi stessi poi si suddividono a seconda di come sono scritti e compilati...

Lo Script invece, sebbene possa avere dei livelli di programmazione, avviene in un ambiente già precostituito, sia un OS, o una determinata applicazione. Quando il caso è quest'ultimo, esso diventa un modo non solo per avere un accesso più diretto ad alcune funzionalità del programma, ma per assemblarle, manipolarle, e costruirne altre in maniera più personale e specifica. Lo script salta il livello dell'interfaccia grafica fatta di icone, palette, menu, ecc. Questo salto se da un lato ci costringe ad abbandonare le certezze di un'interfaccia che conosciamo, dall'altro ci consente di raggiungere un livello di interazione con l'applicazione molto più profondo.

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Lo script arriva direttamente all'inconscio di un'applicazione;

il che vuole essere solo un'analogia per inquadrare meglio la questione....................................................................................................

Ci riferiamo al linguaggio, data la sua sostanziale propensione comunicativa;

Ovviamente il linguaggio a cui fa riferimento lo script, non sarebbe neanche lontanamente paragonabile alla ricchezza del linguaggio umano. Tuttavia riteniamo che la capacità del linguaggio di formulare un pensiero o di esprimere un'emozione, sia preferibile come cornice concettuale finalizzata al progetto di architettura, al concetto più neutro di codice. Altra segnalazione è relativa agli studi di tipo filosofico e cognitivo che hanno avuto e hanno al centro della propria elaborazione il linguaggio stesso. Si tratta della linguistica, che a sua volta ha come oggetto di studio il linguaggio quale sistema comunicativo umano per mezzo di apparati simbolici, e la lingua...

L'impostazione cognitiva classica, vede il linguaggio costruito su delle strutture innate. La questione è complessa e di grande interesse, tuttavia esula i limiti di questo modulo. Ne parlo, poichè come molte delle tematiche delle scienze cognitive, finisce per toccare questioni molto vicine all'architettura quale attività che formula in qualche modo un linguaggio strutturandolo sullo spazio |_|***

Usiamo il termine interfacce, per mettere in evidenza l'esistenza

di più livelli nei quali due enti diversi stabiliscono in qualche modo un contatto>>>>>><<<<<<<<<

Notate che a mio modo di vedere, il problema principale è stabilire sempre un contatto con il mondo, e come questo avviene.................................................................................................................................................._____________________________

Nel nostro caso, pur saltando l'interfaccia classica del programma, alla fine scopriremo di trovarci ancora in un'altra. Questa è senza icone indubbiamente, ma con l'esclusiva strumentazione costituita da un sistema di scrittura basato su un linguaggio costituito da::

simboli e numeri,

funzioni, ovvero strutture di calcolo e parole,

istruzioni, ovvero come ci si comporta,

comunicazioni più o meno dirette fra utente e applicazione,

..................................................................................................................................................................ecc.

E' in questa 'condizione strumentale' così ricca, che stiamo entrando...

Riassumendo velocemente quanto detto fin qui:

In generale l’utilizzo dello script permette un livello di interazione fra user ed applicazione molto più profondo, sia in termini di possibilità che lo script permette, che in termini cognitivi.
Attraverso lo script infatti anzitutto utilizziamo un linguaggio, ovvero comunichiamo più che con delle icone, con l’utilizzo di parole, verbi, espressioni matematiche ecc.

Lo script dunque >>>>>>>>>>>> si regge su una sintassi;

Lo script dunque >>>>>>>>>>>> è un fatto la cui natura è prima di tutto linguistica...

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Altrimenti come farei a dare delle istruzioni?>>>>>>>>>>>>>;-)

Di questa natura linguistica attenzione, ne rileviamo attraverso lo script gli aspetti computazionali ovvero relativi ad un calcolo la cui logica è simbolico-operazionale.

Ambiti dell’uso dello script nel progetto di architettura;
Problema dell’interfaccia: lo script in fondo permette di interfacciarsi ad un livello più profondo con la macchina. Non ho un’interfaccia studiata in base a problemi ergonomici o statistici ho un’interfaccia che è ridotta alla pura scrittura.

La forma di dialogo fra utente-progettista e macchina è come dire più profonda.

Come a dire forzando un'analogia: un dialogo fra 'inconscio dell'applicazione' progetto e luogo del setting.>>>>

In cosa consiste il livello cognitivo dell’operazione.
Lavorare con un sistema simbolico-computazione implica
a) una struttura linguistica
b) una struttura matematica
c) una struttura ponte fra questi due livelli specifici
Loscripting è anche la tecnica di chi ha la convinzione che la matematica da sola sia sufficiente a dare una visione completa del mondo.
Il rischio è quello di avere un’onda di ritorno di un paradigma determinista....

Alcuni livelli:
Il mondo del non lineare non sempre è prevedibile.

>>>Livello descrittivo e livello progettuale
>>>>>>>>>>>>>>>>Analisi della realtà, costruzione del modello e progettuali coincidono.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Più che una cultura del progetto è una cultura dell’interpretazione.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Se lo sia del pensiero dipende dal progettista

Fenomenologia principale

>>>>>Genesi formale attraverso lo script>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Forma
>>>>>Interattività attraverso lo script>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Comportamento

Sotto argomenti:
La natura computazionale - simbolica dei processi informatici;
Cognizione - linguaggio - simulazione
l’algoritmo come modellazione di un fenomeno

Lo script in fondo possiamo vederlo come la scrittura di una 'condizione' spaziale!

ovvero una circostanza necessaria affinchè avvenga qualcosa.... Parliamo dunque di qualcosa di incerto, ancora imprevisto e condizionato.... Un progetto appunto.......................

un momento di attenzione:

quando disegniamo un cubo in una qualsiasi applicazione 3d, in realtà stiamo compiendo delle operazioni che riguardano delle sequenze di 0 e 1! Tutto questo avviene a dei livelli abbastanza complessi dei quali non ci occupiamo e che riguardano in ultima istanza il calcolo che avviene nella CPU del computer… In altre parole è qui che interviene la computazione, di cui si è parlato…

Quando infatti chiediamo il valore di una certa funzione y=f(x) come ad esempio y = sin (x) con x = 30°, il computer sta facendo qualcosa che potremo considerare come un’implementazione digitale della famosa formula di Taylor:

Formula che più che spaventarci, deve al contrario ricordarci che il computer sta approssimando mediante un polinomio di grado n, la funzione proposta. Niente di più e niente di meno.
Per questo dico che quando utilizziamo uno script stiamo lavorando cognitivamente su un livello che è simbolico – computazionale:

ci avvaliamo cioè di simboli in grado di esprimere delle quantità variabili e dei percorsi operazionali, e di calcolo in quanto tale…
Ma come possiamo considerare l’utilizzo dello script nel progetto architettonico?
Cos’è che cambia se ragioniamo in lingua più che in forma?

Questo qui sotto è quello che succede con l'interfaccia classica....

Immaginiamolo di scriverlo, e scrivendolo apriamo delle sfumature, molto più articolate di quelle che vediamo in superficie.....

Ora parliamo di architettura:

Ci riferiamo alle analisi su un progetto di Eisenman che Saggio fa in questo libro: qui

poichè stiamo entrando in un mondo di condizioni, cioè di:

;:;:;:;:;:;:;:;:;:;:;:;:;:;:;:;possibilità

________________||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||simulazioni

emersioni di dimensioni formali dove la scrittura della forma è ad un livello molto fine e profondo.....

Dico scrittura perchè la storia ovvero la genesi si è svolta come afferma lo stesso Watanabe fra 2 estremi, che a ben vedere sono sempre presenti nella storia di un progetto:

Random :...::......_._:__...._____:::::...._____e.....____________________:::::::::::::::::Ordine!

che costituiscono ancora due modi di vedere il mondo 'in-formazione' di cui ci parla il Prof. Saggio....

E qui ancora un altro classico, dove scrivere queste condizioni implica porsi il problema della progettazione della crescita e dell'autogenerazione della forma ................

oltre a delle dimensioni più squisitamente 'politiche' e visionarie (nel senso virtuoso, intelligente e provocatorio del termine)!

Al lavoro per una demistificazione della forma:

Leggiamo prima questa definizione, a cui personalmente tengo tantissimo:

‘Architectural theory cannot deliver the truth about architecture. Even in philosophy, the status of truth as the absolute value and goal of the investigation has been questioned since Nietzsche. Instead of a search for truth, philosophy was for him a practice of demystification,unmasking and genealogy,ultimately aiming at emancipation’. (Kary Jormakka`*)

Kary Jormakka è un Teorico dell'Architettura che vive e lavora a Vienna alla Technische Universität.

Abbiamo visto come i piani di utilizzo di una tecnica script sebbene diversi (esecuzione di un task da parte di un artefatto oppure computazione di una genesi formale) condividano tuttavia un elemento comune la cui importanza è a dir poco cruciale:
L’utilizzo dello script rivela la sua natura modellistica; in realtà utilizzando uno script si fa un focus su un fenomeno formale considerato in maniera dinamica.
A questo punto delle keywords sulle quali impostare un pensiero potrebbero essere:
Algoritmo>>>>>>>>>modello (scientifico?) di un fenomeno (geometrico, strutturale, biologico,ecc.)
Simulativo>>>>>>>>simulazione di un modello; ovvero le attitudini comportamentali di quel modello considerate in maniera dinamica.
Chiariamo anche il significato profondo di questo termine: dinamica poiché è relazionata al tempo, ma anche perché prevede un’esistenza (sic) del modello comportamentale. Cosa succede se una goccia d’acqua impatta una certa superficie dotata di una specifica forma, di un certo coefficiente di rugosità, ecc. ecc.?

demistificare

Evidenziazione dell'aspetto reale di un comportamento, di un'ideologia ecc., che viene così sfrondato dei suoi tratti esteriori, spesso ingannevoli....

http://www.youtube.com/user/mpan3

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>la forma

è intrinsecamente dinamica; non è un fine ma un processo; anche quando sembra immobile!

possiamo immaginare una forma processuale fuzzy e sfumata naturalmente...................

Diller&Scofidio per l'appunto;

Progettare un'architettura è dunque manipolare un processo sia durante la fase di progettazione che durante la fase effettiva di vita di un edificio. In quest'ultimo senso la progettazione di un edificio è progetto di cicli vitali... Lo script in questo senso? ...Tratteremo questi nei prossimi moduli che avranno anzitutto carattere applicativo..............

Nota: quando non diversamente specificato si intende che gli Script qui presentati, sono tratti dalla guida Ufficiale di RhinoScript, e sono a cura di:

David Rutten
Robert McNeel & Associates,
il cui testo è liberamente scaricabile da Internet all'indirizzo:
http://en.wiki.mcneel.com/default.aspx/McNeel/RhinoScript101.html

alcuni di questi script visto il loro carattere esplicitamente didattico sono qui riportati integralmente. Questa scelta deriva dal fatto che si è ritenuto più utile abituare gli studenti ad un percorso didattico proposto in maniera ufficiale dalla stessa compagnia che produce Rhino e che potranno proseguire o meno in totale autonomia, dopo aver concluso i primi moduli. Altri script sono invece modificati in parte o in maniera più radicale; i fini di queste operazioni sono naturalmente ancora esclusivamente didattici.

1) Cominceremo oggi, con una distinzione fondamentale: Rhino come molti altri programmi può essere controllato attraverso una command-line; Anche qui, - come altrove - attraverso l’uso della tastiera possiamo scrivere qualcosa del tipo:

_Line 0,0,0 10,0,0 (o in italiano digitate semplicemente linea)...
Abbiamo scritto una riga di comando; ne possiamo comunque scrivere molte, facendo una sorta di LISTA di COMANDI.
Questa lista però, non è uno script, bensì una MACRO che possiamo considerare come il livello più basso di programmazione…
Line 0,0,0 10,0,0

è una macro semplicissima; diciamo al programma di disegnare una linea attraverso le coordinate di 2 estremi e…. Basta!
Per certi versi la Macro al massimo ci aiuterebbe ad automatizzare alcuni compiti...

Osservazioni: è già evidente l’uso di un sistema di coordinate cartesiane tridimensionale; valgono quindi tutte le definizioni ed osservazioni fatte nei corsi di Matematica. Avremo un’origine degli assi coordinati, delle relazioni di perpendicolarità e possiamo usare alternativamente le coordinate cartesiane o quelle polari… (Vi ricordate?)

Del resto se usate Rhino, avrete già familiarità con questi concetti.

Tutto questo può essere detto in modo molto più raffinato, utilizzando un concetto matematico ancora più potente e utile dentro Rhino, ovvero quello di:

-------------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>> Vettore!

((((((Digressione: Domanda - cos'è un vettore? - )))))))))))))))))

Il vettore è dunque, prevalentemente Informazione;

certo, è vero che rappresenta un punto nello spazio, ma non lo rappresenta in modo assoluto, bensì relativo. Il vettore in sostanza esprime una distanza da un'origine e una direzione nello spazio.

(Chi si ricorda?)

2) Lo script supera le limitazioni delle macro ed avviene secondo uno spazio intermedio fra MACRO e PLUGIN. Ma quali sono le differenze con le MACRO?

Teniamole bene a mente perché ci aiuteranno a scrivere meglio i nostri script:

a) Lo script non è una semplice LISTA di comandi del tipo: disegna questo, fai quest’altro ecc. ecc.

b) Nello script, poiché si esegue una riga alla volta, possiamo decidere di spostarci su un’altra riga, quindi posso saltarne alcune ed eseguire altre

(((((((Questo è un concetto fondamentale della programmazione script)))))

Si tratta del concetto di ------------------------------------>>>>>>> FLOW CONTROL
Ovvero del conditional evaluation.... (Un attimo che ci torneremo:-))

c) All’interno dello script possiamo eseguire calcoli matematici, e poi valutare i risultati....

------>da questi produrne altri sulle basi dei risultati precedentemente ottenuti;

d) L’interazione fra l’applicazione e l’utente come si è già detto l’altra volta ad un livello di comunicazione più profondo...

In sintesi:

Flow control-----------------------------Variable Data ------------------------------Communication

Variabile.... Cosa significa che una cosa è variabile? Tanto per accostarci intuitivamente a questo aspetto significa che qualcosa è intrinsecamente dinamico!!!
Ma, se dovessimo parlarne in modo più rigoroso e soprattutto orientato alla pratica della programmazione, diciamo che :

Possiamo immaginare le variabili come dei magazzini nei quali mettere delle quantità intrinsecamente dinamiche... Cosa faccio praticamente?

A)------------------------------------->>>>>>>>>>>>>>>>Assegno quindi una variabile per immagazzinare un certo valore

B)---------------------------------------------------->>>>>>>>>>>>>>>>>>>>>>Richiamo quel valore quando voglio e lo valuto

C)---------------------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>Immagazziniamo dei numeri allora!!!!!!!!!!!!

Immaginare le variabili come delle box, insomma, potrà aiutarci parecchio;

Altro esempio:

se da qualche parte, scrivo (vedremo poi come):
X = 4

e poi ancora scrivo un'altra riga del tipo:

Curva = Rhino.Addline (Array (0,0,0), Array (X,0,0))

Cosa ho scritto?

(Facciamo delle osservazioni...)

Come vedete tutto quanto detto non è niente di nuovo rispetto a quanto studiato in analisi matematica - per esempio -sul concetto di funzione, dove tiriamo in ballo continuamente delle variabili (dipendenti o indipendenti)!

Però bisogna sapere Rhino come lavora con delle variabili, quindi qui annoiamoci un po’….

Come altri linguaggi script (maxscript, e processing per esempio) Rhino dialoga con questi tipi di variabili:

1) INTEGERS

2) DOUBLES

3) BOOLEANS

4) STRINGS

5) NULL VARIABLE

E facciamo una digressione su queste tipologie poiché vi accorgerete che è importante sapere quando e come usarle....

2) Doubles

E procedendo secondo una logica nota di ampliamento degli insiemi numerici, proprio come in matematica viene quasi spontaneo aggiungere - ampliando quest'altro insieme.

Questi sono i numeri decimali. Cos’è un numero decimale? Il range anche qui è abbastanza esteso, quindi nulla da aggiungere se non il fatto che usiamo questi numeri prevakentemente per calcolare.

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Facciamolo subito:
Esercizio: assegnamo le seguenti variabili:

X = 12+34.78905

Y = sin (x)

Z= Sqr (2)

K = sin (X+Y+Z)*Sqr (X*Y*Z)

Notiamo che oltre al semplice calcoletto abbiamo già definito con le nostre variabili, delle relazioni… Quindi un livello leggermente più complesso di quello precedente…

Analizziamo quanto scritto... (((Digressione))))))))))))

E' già chiaro che valgono tutte le convenzioni usate normalmente nei corsi di matematica; i calcoli quindi saranno fatti in modo tale da rispettare in un'espressione la precedenza di moltiplicazioni e divisioni, ecc. ecc.

E se, dovessi trovarmi a scrivere un calcolo come una funzione di questo tipo???? (La funzione è proposta nella guida allo script di Rhino, ma potrei scriverne un'altra ancora più difficile):

Come faccio a scrivere il mio calcolo?

Niente paura:----------------------------->>>>>ovviamente la spezzetto in pezzettini più semplici!

come? ovviamente essendo il più possibile sintetici, com'è nella modalità della scrittura matematica:

(infatti:)

con questo abbiamo già accennato a concetti come quello di operatore e di funzione che comunque esamineremo meglio, visto il significato enorme che hanno in Rhinoscript;

3) Booleans

Si tratta delle variabili che fanno riferimento all’algebra Booleana (piccola digressione)… Perché usarle?
Immaginiamo di chiedere a Rhino la cosa seguente:

Riempi il parallelepipedo con gli oggetti che ho disegnato, e fai in modo che gli oggetti non abbiano mai ad intersecarsi, quando lo spazio disponibile è più piccolo dei più piccoli fra gli oggetti a disposizione, smetti di eseguire questo compito..................................!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Detto forse in modo poco elegante, certamente, ma efficace per capire che stiamo non solo chiedendo a Rhino di eseguire dei compiti abbastanza precisi, ma come leggete bene Rhino è costretto per passare al compito successivo a verificare continuamente delle cose; ad esempio dovrà ad un certo punto verificare che lo spazio disponibile non sia più utilizzabile.

---------------------------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Ho quindi una frase nella quale è implicita una condizione

Come fa a verificarlo? .........Utilizzando ad esempio varibili booleane;

Rhino cioè valuterà se una determinata condizione è:

TRUE (vera)
FALSE (false)

Questo è il linguaggio che usa Rhino, non 0, non 1, e neanche On oppure Off…

4) Stringhe

Per capire bene il senso della cosa facciamo così:

a=1234
b=“1234”

Chiediamo a Rhino di stamparle a schermo:

Rhino.Print(a+a)
Rhino.Print(b+b)

Che succede? Commentiamo i risultati
Nel primo caso ho usato una varibile numerica, mentre nel secondo ho usato una stringa, che più che testo dobbiamo pensarla come una scritta (detto in maniera poco elegante)! Tutto quello che scriviamo infatti è 'solo' testo.

Facciamo altri giochetti:

A=“pasta”
B=“pasta”&”ceci” Rhino.Print(b)
C=“pasta”& “ “ & “ceci” Rhino.Print C
D = “Il coseno dell’arco di 0 radianti è uguale a” & cos(0)

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

Insomma, la stringa è immagazzinata come serie di caratteri.

------------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>Ogni carattere è preso dalla tavola UNICODE.....

Il segno &, mette quindi più variabili insieme…

Nota bene:

Non sottovalutate le stringhe. Rhino infatti per immagazzinare l’ID Object usa proprio delle stringhe. Cos’è l’ID Object? E’ come dire, la carta di identità di ogni oggetto che popola Rhino. E’ quindi qualcosa di unico, inconfondibile, e necessario per operare con gli oggetti.

4) La Variabile Nulla

aaaaaa

Discutiamone.
Si capisce che la variabile nulla - If IsNull(La_Nostra_Curva) - serve a riportare Rhino nella logica ed a consentirgli di dire:
Non lo so fare:-(

Nel caso predente infatti si sarebbe prodotta una grande ambiguità, onde evitarla, diciamo a Rhino che se aveva trovato dei valori nulli, poteva dirci che la cosa non funzionava e porre termine all’esecuzione dello script.

Tutto ciò premesso come usiamo queste variabili?

>>>>>>>>>>>>>>>ANZITUTTO LE VARIABILI VANNO DICHIARATE!

Attenzione c’è una parola chiave per farlo che è:

------------------------------------------------>>>>>>>>>>>>>>>>Dim

E' chiaro che questo è il significato di questa parola che abbiamo già visto in questa lezione.
Dim, ci dichiara una variabile locale, cioè usata in quello script o in una certa parte di esso e basta.
Posso anche dichiarare variabili globali, ma ciò diciamo che è un po’ più pericoloso… Quindi per ora ci occupiamo di quelle locali…
La variabile può anche essere dichiarata in una funzione, quindi in quel caso solamente la funzione avrà accesso ad essa… Potrà cioè leggerla, scriverla, modificarla, ecc.

Notiamo infine un'altra parola chiave che abbiamo nello script:

Option Explicit.... Cosa significa?

E' importante aprire lo script con questo termine, poichè stiamo dicendo a Rhino che dichiareremo esplicitamente tutte le variabili;

se non lo facciamo, accade che ci pensa lui, ma questo non ci conviene per niente... Poi capiremo perchè;

Sotto questa riga troviamo un'area grigio chiaro, dove le frasi cominciano con la virgoletta;

in questo modo possiamo scrivere quello che vogliamo, (ad esempio commenti sulle righe; annotazioni, ecc.); Rhino salterà questa riga 'sapendo' che sono parole dette solamente per noi...

Il concetto di funzione, importantissimo nella programmazione script, non dovrebbe affatto essere nuovo per noi:

Ad esempio la scrittura:

y = f (x)

cosa significa?

((digressione sul concetto di funzione))))))))

Terminologia in uso:

function

subroutine

methods

ci torneremo meglio, ma quello che ora è importante sapere è in Rhino a cosa servono le funzioni:

La cosa da dire assolutamente è, che da un punto di vista generale, una funzione serve ad incorporare qualcosa, e questo 'incorporamento' prevede un valore in entrata ed uno in uscita.

Questo da un punto di vista generale, perchè abbiamo anche casi di funzioni dove non c'è alcun valore in ingresso e in uscita....

Sono naturalmente funzioni:

cos(x)

log (x)

o anche 2sin(x)+logz

o più tipiche di Rhino:

Rhino.AddPoint(...................)

Rhino.AddLayer(..................)

Una funzione cioè ha degli argomenti (in genere più di uno, alcuni dei quali vanno dichiarati obbligatoriamente, altri sono opzionali)

Se non dichiariamo valori, dobbiamo usare la parola call

Commentiamo questo piccolo script:

1) Abbiamo una semplice funzione RenameObject;

2) Poi c'è la parola Sub, che sta per Subroutine, che viene ' inaugurata' alla linea 7; è naturalmente la subroutine relativa alla funzione RenameObject;

3)Notiamo che subito dopo attraverso la parola Dim (che ormai conosciamo bene) stiamo dichiarando una variabile la quale dal nome, che le abbiamo dato, dovrebbe immagazzinare l'ID dell'oggetto in Rhino; ma ora non sappiamo se sarà una stringa, un numero o qualcos'altro...

4) Subito dopo diciamo che questa variabile è uguale ad un 'metodo',ovvero il Rhino.GetObject (che generalmente serve a prendere-selezionandolo un oggetto nell'ambiente); come lo prendo questo oggetto? A ciò servono gli argomenti fra parentesi: il primo è una stringa (ricordate l'uso delle virgolette?); gli altri non sono dichiarati, tranne l'ultimo che è un booleiano (in questo caso True = vero); ricordate che abbiamo detto che spesso gli argomenti non sono tutti obbligatori?

5)Ora, se notate per evitare che la funzione provochi qualcosa di strano, ci tuteliamo con la variabile Nulla, la cui utilità,è stata già considerata a lezione; difatto dico che se è nulla, usciamo dalla Subroutine, per piacere, senza fare storie (diciamo proprio così);

6)Mentre se l'operazione va a buon fine, e Rhino si ritrova con un oggetto selezionato, abbiamo bisogno di una variabile che immagazzini il nuovo nome, che ci dica come lo vogliamo, com'è fatto; a questo provvede la linea nella quale dichiaro una nuova variabile; ho cambiato il nome in Italiano apposta per farvi capire che Str sta per stringa e che il nome lo decidiamo noi;

7)Una volta dichiarata dico che c'è dentro: troviamo una stringa (quindi Rhino da qualche parte ci stamperà la dizione Date Tag, e qualche altra cosa. Avete visto il carattere '&'? Chi si ricorda a cosa serve? L'altra cosa che ci stampa è: CStr(Now()); attenzione partiamo da quello che c'è in parentesi: Now mi prende la data e l'ora del sistema, dopodichè per farmelo concatenare alla stringa 'Date Tag' ho bisogno di convertirlo in stringa ed a questo compito ci pensa proprio la funzione CStr! (Perchè lo devo convertire in stringa?) - E' chiaro che la data e l'ora presa da un sistema, costituisce un genere di dati diverso dalla semplice stringa!

8) A questo punto diciamo a Rhino di chiamare la funzione Rhino.ObjectName per finire il nostro compito. Notiamo che gli argomenti della funzione saranno le due varibili che abbiamo completamente determinato, ovvero StrobjectID e StrNuovoNome; a questo punto possiamo dirgli di finire tutto;

Alcune considerazioni sulle funzioni;

Abbiamo visto come le funzioni, assumano una loro vitalità ed un loro senso attraverso l'uso degli argomenti; abbiamo anche visto come essi siano per lo più delle quantità variabili e la loro definizione precisa, ci aiuta a far lavorare bene la funzione; dobbiamo però fare ora alcune considerazioni su come i valori agiscano nel corpo della funzione e su come i valori ad essi connessi siano utilizzati dalla funzione stessa;

Esistono infatti modi diversi per dichiarare gli argomenti in una funzione; questo può avvenire attraverso:

by value o by reference

by value:

In questa lezione entriamo nel vivo di alcune procedure che caratterizzano in generale lo script, e che per certi versi ne giustificano alcune modalità di utilizzo;

Si tratta delle >>>>>>>>>>>>>procedure iterative; e

dei >>>>>>>>>>>>>>>>> cicli condizionali, ovvero

come far eseguire a Rhino certi compiti noiosi, e che prevedano il verificarsi ci certe condizioni;

vediamo subito alcuni esempi proposti dalla guida:

1) Se l'oggetto è una curva, cancellalo;

2)Se l'oggetto è una curva breve, cancellalo;

3)Se l'oggetto è una curva breve, cancellalo, altrimenti spostalo sul layer 'curve';

Facciamo delle osservazioni:

Troverete non solo su RhinoScript, ma anche su altri linguaggi che l'If Then Statement, è quello più comune;

la sua struttura logica come si vede dagli esempi sopra, è del tipo:

If (se) qualcosa o qualcos'altro è in un certo modo Then (allora)

fai qualcosa

else (altrimenti) qualcos'altro

End If (Poi smettila;-))

Come abbiamo visto nel modulo precedente, si tratta di usare logicamente delle strutture linguistiche chiave;

tuttavia quando abbiamo condizioni molteplici e diverse nel nostro lavoro formale, usare quella struttura diventa un po' complicato...

Possiamo far ricorso ad un'altra 'struttura linguistica':

Select case che chiamerei in gergo e solo per capirci, 'puta caso';-)

Lo uso appunto, per semplificare situazioni come quella precedente, anche se vedremo che se è vero che da un lato semplifica, dall'altro funziona essenzialmente da

operatore di uguaglianza (=)

Select case variabile_tale

case 0

fai qualcosa

Ecco perchè per ogni case, ho quei numeri, e il metodo select case non fa altro che verificare se i numeri dell'oggetto corrispondono ad uno di essi;

......................................................................................................................questo infatti viene detto alla riga 14, con IntObjectType;

...................................................................................Per questo vi dicevo che funziona un po' come un operatore di eguaglianza;

Una volta verificato lui fa qualcosa; in questo caso trasferisce gli oggetti sul layer di pertinenza in relazione ai dati ottenuti;

...................................................................................................Notiamo infine le istruzioni che creano il layer qualora non ci fosse;

Dichiaro alcune variabili chiave, che mi serviranno ad immagazzinare i dati necessari per far funzionare il processo;

si tratta di 5 variabili (2 alla prima riga Dim, e altre 3 alla seconda); il significato è piuttosto ovvio, tuttavia:

non solo; l'altra variabile si chiama STEP (in Italiano possiamo chiamarla 'passo'); che significa?

Una prima cosa che vi propongo è quella di cambiare la funzione Rhino.AddPoint, con Rhino.Addsphere

attenzione per un corretto uso della sintassi relativa a questa funzione, necessitiamo dei seguenti argomenti:

Rhino.AddSphere (arrCenter, dblRadius)