Il Prossimo Giovedì 20 Gennaio 2011 alle ore 18:00
alle  presso la sede dell'ISTITUTO QUASAR
via Nizza, 152 - Roma

si terrà la lecture Cloud Design, in cui saranno presentati
progetti e lavori compiuti anche durante le attività di Tecniche Parametriche
di progettazione 2008-2011. Siete tutti invitati a partecipare, e intervenire!

cloud design
la lecture indaga l'evoluzione dei metodi di progettazione e produzione, che a partire da presupposti e provocazioni tecnologiche conduce alla evoluzione dei profili professionali e umani. Non si tratta, quindi, solo di riconoscere nuove forme di autorialità nel cloud computing per produrre spimes e strutturare gruppi allargati e flessibili di produzione, ma progettare per le nuove forme organizzative, usando flessibilità e negoziazione come forme espressive e il networking sui server di progettazione come strumento operativo.
Per passare dal solipsistico parametric modeling al "parametric being".

Cari ragazzi,
tra i temi che molti di voi stanno esplorando, discussi più volte al corso,
c'è la variazione dei componenti costruttivi. Di seguito vi segnalo diverse
tecniche:

1. Revit 2010 - "Power Copy" script

Lo script, usato tra gli altri progetti, per la Lampada Nagashima,
è stato sviluppato durante lo scorso anno per permettere di effettuare
copie "intelligenti" di un componente, che ad ogni passo, permettesse anche
di variare dei parametri. L'ultimo esempio che pubblichiamo qui, sviluppato
da Stefano Guarnieri per il progetto Calatrava/superficie rigata di Valeria Vitale



Il vantaggio di questa tecnica è che permette di schedulare i valori dei parametri
(come si vede dalla immagine qui sopra, dove ogni componente ha dimensioni leggibili)


2. Revit 2011 - Componenti adattativi e Reporting Parameters

L'intento che lo script 2011 si prefiggeva è stato, nel frattempo "raggiunto" dallo sviluppo
software, come accade sempre più spesso nel recente panorama in cui cresce la capacità
di scripting da parte degli "utenti" e dei progettisti impegnati nella implementazione reale
nell'attività progettuale e realizzativa.

In particolare le funzioni, nuove, che permettono un controllo analogo sono
i componenti adattativi e i Reporting Parameters (Parametri di rapporto).

Del componente adattivo si è detto a lezione, paragonandolo a tutti gli altri sistemi
di controllo e produzione della variazione, primo tra tutti Generative Components,
software nato col nome di Custom Objects e precursore del settore, a cui si aggiungono
le "User Feature" di molti software di progettazione meccanica e, in ultimo, le diverse
opzioni concesse dal plug-in di Rhino Grasshopper.


Biennale di Venezia, 2010

I progetti che si occupano nel corso di questo tema sono, al momento, quello di
Lorenzo Catena, che mima il progetto di SHoP per la copertura del centro Post-Katryna
nei pressi New Orleans:



E quello, parallelo in corso di sviluppo, di Ivo Petri

A questa nuova modalità concessa da Revit, per lavorare questi temi su base eminentemente grafica,
si somma la necessità di controllare matematicamente le geometrie di progetto. Su questo tema,
si sono svolti incontri con il contributo del prof. Corrado Falcolini, del Dipartimento di Matematica, che ha
anche dato un contributo al Seminario "Forma e disegno nell'architettura del sei e settecento".

Sul tema del controllo matematico delle geometrie in Revit con metodi grafici, si è interessato
Giuseppe Di Fabio, citando anche il lavoro di "The Revit Kid":



Giuseppe è ora impegnato nella produzione di variazioni architettoniche del tema
di una copertura/portico a generatrici pseudo-sinusoidali.

Al tema della variazione architettonica di un componente
lucernario/copertura, infine si sta interessanto Elena Valik,
che a partire da un progetto per una piccola pensilina, e alla
parametrizzazione di un lucernario come pattern basato su tre punti,
sta ora passando alla produzione di vari componenti di chiusura orizzontale
per un sistema di copertura e lucernari a modulo triangolare variabile




Aspettiamo ora da Elena gli aggiornamenti del lavoro di parametrizzazione
e le sue applicazioni architettoniche.


Sostanzialmente i lavori di questa sezione richiamano i due possibili
contesti per un lavoro architettonico sulla variazione:

1 .  serie
la produzione di pezzi autonomi (o di design) con geometria variata nella serie.
Il paradigma della mass customization che abbiamo no inquadrato negli anni
in quello Beyond IKEA

2. pezzi unici
la produzione di oggetti architettonici fatti da componenti dalla geometria
variabile, a cui fanno riferimento moltissimi progetti della contemporaneità
e quelli prodotti nel Laboratorio di Tecniche Parametriche 2011.


Ha senso, però, in fondo, parlare in questi termini di distinzione?
Non si tratta anche di cambiare un pò il modo di progettare e renderlo più "diffuso"?
Figlio di questa "nuova standardizzazione fatta di pezzi diversi"? A questo tema è ispirata
la pubblicazione, e il concetto collegato, di versioning ipotizzato da SHoP Architects.

A voi, ora fare le vostre riflessioni parallele ai progetti che elaborerete.

Buon lavoro!





 

Store_Selections - It builds some virtual boxes, where recovering the past selections to compare each other

Random_Selection_Panels - It picks, accidentally, a number of panels between the selected, equal to the chosen percentage

Set_Color_In_View - It changes the color of the edges of each type, in the active view

Bridge_Of_The_ Peace - It places points in the space, following the shape of the roof of a bridge - Conceptual mass

Physical_ID - Before it loads a family in the .rvt, then it creates and rotates some istances of it

S.A.T.: the Truss - Writing and reading of text files to interact with other softwares

Setting_Line_Color - This code allows to set the color of all the lines within the document

Shape_Discovering - This code shows, by listing, the relationship between points and 3D snapped model lines - Conceptual mass

Line_By_Selected_Points - This code creates a line joining two selected points - Conceptual mass

Get_Nodes - This code lists some features of a Structural Frame (columns and beams) - Project Based

Naming_ReferencePoints  - This code allows to assign a "personal id" number to each reference point in the Comment Field - Conceptual mass

New_Caledonia -  This sample creates new family instances along an arc (inspired by Renzo Piano's project)

--
All the examples require Login to download the files

Titolo Aggiornamentoordinamento crescente Creazione Nuovi commenti tags Autore
seduta_linee costruzione 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine francescabottaro
inserimento arredo 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine francescabottaro
P5 (famiglia di pannello) 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine, Projects, Rivestimento di facciata esterna, Tecniche Parametriche Arbjona Koxhaj
P3viola (famiglia di pannello) 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine, Projects, Rivestimento di facciata esterna, Tecniche Parametriche Arbjona Koxhaj
P4 (famiglia di pannello) 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine, Projects, Rivestimento di facciata esterna, Tecniche Parametriche Arbjona Koxhaj
3a, Vista prospettica dell'edificio 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine, Projects, Rivestimento di facciata esterna, Tecniche Parametriche Arbjona Koxhaj
2a, Prospetto sud-est 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine, Projects, Rivestimento di facciata esterna, Tecniche Parametriche Arbjona Koxhaj
1a, Prospetto sud-est 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine, Projects, Rivestimento di facciata esterna, Tecniche Parametriche Arbjona Koxhaj
4a, Vista prospettica 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine, Projects, Rivestimento di facciata esterna, Tecniche Parametriche Arbjona Koxhaj
5a, Vista prospettica 3 mesi 3 settimane fa 7 anni 9 mesi fa Immagine, Projects, Rivestimento di facciata esterna, Tecniche Parametriche Arbjona Koxhaj

Pagine

 

Thanks to prof. Todesco for his vital help.

FileInfo t = new FileInfo(@"C:\Documents and Settings\Gguarnieri\Documenti\Desktop\TrussData.txt");
            StreamWriter Tex = t.CreateText();
            Tex.WriteLine("BARS LIST");
            Tex.Write(Tex.NewLine);
            Tex.Write("{0}_________", "ID");
            Tex.Write("{0}_________", "lenght");
            Tex.Write("{0}_________", "from node");
            Tex.Write("{0}_________", "to node");
            Tex.Write(Tex.NewLine);
            Tex.Write("-----------------------------------------------------------------------------------------");
            Tex.Write(Tex.NewLine);
 
            SetVertici vertici = new SetVertici();
            double ConvMeter = 0.3048;
            int approx = 2;
            int numBars = 0;
            Level level=null;
            ElementIterator levelIter = Application.ActiveDocument.get_Elements(typeof(Level));
            levelIter.Reset();
            while (levelIter.MoveNext())
            {
                Level level1 = levelIter.Current as Level;
                if (level1.Elevation > 0)
                {
                    level = level1;
                }
            }
            ElementIterator elemIter = Application.ActiveDocument.get_Elements(typeof(FamilyInstance));
            elemIter.Reset();
            
            while (elemIter.MoveNext())
            {
               
                FamilyInstance FamInst = elemIter.Current as FamilyInstance;
                StructuralType StructType = FamInst.StructuralType;
                Location Loc = FamInst.Location;
                ElementId ElemId = FamInst.Id; 
                
                string familyName = FamInst.Name;
                string NameFam = ElemId.Value.ToString();
                int giunto = 0;
                Vertice v = null;
 
                if (familyName == "cone")
                    {
                        giunto = 1;
                        LocationPoint point = Loc as LocationPoint;
                        v = vertici.getVertice(point.Point,giunto);
                        
                        
                    }
                    else if (familyName == "cylinder")
                    {
                        giunto = 2;
                        LocationPoint point = Loc as LocationPoint;                        
                        v = vertici.getVertice(point.Point,giunto);
                        
                     
                    }
 
                else if (StructType == StructuralType.Beam || StructType == StructuralType.Brace)
                {
                    
                    numBars = ++numBars;
                    LocationCurve CurveLoc = Loc as LocationCurve;
                    Curve curve = CurveLoc.Curve;
 
                    XYZ StartPoint = curve.get_EndPoint(0);
                    XYZ EndPoint = curve.get_EndPoint(1);
 
 
                    Vertice v0 = vertici.getVertice(StartPoint, giunto);
                    string id0 = v0.id.ToString();
 
                    Vertice v1 = vertici.getVertice(EndPoint, giunto);
                    string id1 = v1.id.ToString();
 
                    
                    
                    string lenght = (Math.Round((curve.Length) * ConvMeter, approx)).ToString();
 
 
                    string data = String.Format(" {0}      {1,16}     {2,15}     {3,20}", NameFam, lenght, id0,id1);
                    Tex.WriteLine(data);
                   
                    Tex.WriteLine("-----------------------------------------------------------------------------------------");
                    
                   
                }
                else if(StructType== StructuralType.Column)
                {
                    
                    numBars = ++numBars;                    
                    LocationPoint point = Loc as LocationPoint;
                    Vertice v0 = vertici.getVertice(point.Point, giunto);
                    string id0 = v0.id.ToString();
                    Vertice v1 = vertici.getVertice(v0.x,v0.y,level.Elevation,giunto);
                    string id1 = v1.id.ToString();
 
                    string lenght = (Math.Round((v0.distance(v1)) * ConvMeter, approx)).ToString();
                    
                    string data = String.Format(" {0}      {1,16}     {2,15}     {3,20}", NameFam, lenght, id0, id1);
                    Tex.WriteLine(data);
 
                    Tex.WriteLine("-----------------------------------------------------------------------------------------");
                }
                
            }
 
 
 
            Tex.Write(Tex.NewLine);
            Tex.WriteLine("NODES LIST");
            Tex.Write(Tex.NewLine);
            Tex.Write("{0}_________", "NUMBER");
            Tex.Write("{0,5}_________", "X");
            Tex.Write("{0,5}_________", "Y");
            Tex.Write("{0,5}_________", "Z");
            Tex.Write("{0,5}_________", "JOINT");
            Tex.Write(Tex.NewLine);
            Tex.Write("-----------------------------------------------------------------------------------------");
            Tex.Write(Tex.NewLine);
            for (int i = 0; i < vertici.Count(); i++)
            {
                
                Vertice v = vertici.at(i);
                string giunto = "";
                if (v.joint == 0)
                {
                    giunto = "unknown";
                }
                else if (v.joint == 1)
                {
                    giunto = "cone";
                }
                else if (v.joint == 2)
                {
                    giunto = "cylinder";
                }
 
 
                Tex.Write("{0,3}", v.id.ToString());
                Tex.Write("{0,20}", (Math.Round((v.x) * ConvMet, approx)).ToString());
                Tex.Write("{0,20}", (Math.Round((v.y) * ConvMet, approx)).ToString());
                Tex.Write("{0,20}", (Math.Round((v.z) * ConvMet, approx)).ToString());
                Tex.Write("{0,20}", giunto);
                Tex.Write(Tex.NewLine);
                Tex.Write("-----------------------------------------------------------------------------------------");
                Tex.Write(Tex.NewLine);
            }
 
            Tex.Write(Tex.NewLine);
            Tex.Write("{0,10}_________", "BARS number");
            Tex.Write("{0,10}_________", numBars.ToString());
            Tex.Write("{0,10}_________", "NODES number");
            Tex.Write("{0,10}_________", vertici.Count().ToString());
 
            Tex.Close();     
          }           
 
 
public class SetVertici
    {
 
        List<Vertice> vertici = new List<Vertice>();
 
        public Vertice getVertice(double x, double y, double z, int joint)
        {
            Vertice posizione = new Vertice(x, y, z, joint);
      
            Vertice piuVicino = null;
            double distanza2Minima = 0;
            
            for (int i = 0; i < vertici.Count(); i++)
            {
           
                double distanza2 = vertici[i].distance2(posizione);
                int giuntoVero = vertici[i].joint;
                if (giuntoVero != 0 && distanza2<5)
                {
                    posizione.joint = giuntoVero;
                }
 
                if (piuVicino == null || distanza2 < distanza2Minima)
                {
                    piuVicino = vertici[i];
                    distanza2Minima = distanza2;
                }
            }
           
            if (piuVicino != null && distanza2Minima < 1)
            {
                piuVicino.joint = posizione.joint;
                return piuVicino;
            }
           
 
            posizione.id = vertici.Count();
            vertici.Add(posizione);
 
 
            return posizione;
        }
 
        public Vertice getVertice(Autodesk.Revit.Geometry.XYZ coords,int tipoGiunto)
        {
            return getVertice(coords.X, coords.Y, coords.Z,tipoGiunto);
        }
        public int Count()
        {
            return vertici.Count();
        }
 
        public Vertice at(int index)
        {
            return vertici[index];
        }
 
    }
 
 
public class Vertice
    {
   
        double _x;
        double _y;
        double _z;
        int _id;
        int _joint;
        
        
 
        public Vertice(double x, double y, double z, int TipoGiunto)
        {
            _x = x;
            _y = y;
            _z = z;
            _id = -1;
            _joint = TipoGiunto;
        }
 
      
        public double x
        {
            get { return _x; }
 
        }
 
        public double y
        {
            get { return _y; }
 
        }
 
 
        public double z
        {
            get { return _z; }
 
        }
        
        public double distance2(Vertice v)
        {
            return Math.Pow(v.x - _x, 2) + Math.Pow(v.y - _y, 2) + Math.Pow(v.z - _z, 2);
        }
 
      
        public double distance(Vertice v)
        {
            return Math.Sqrt(distance2(v));
        }
 
        public int id
        {
            get { return _id; }
            set { _id = value; }
        }
 
        public int joint
        {
            get { return _joint; }
            set { _joint = value; }
        }
    }

[ 2011 ]  l'evoluzione dei metodi di progettazione e produzione,  a partire da presupposti e provocazioni tecnologiche conduce alla evoluzione dei profili professionali e umani. Non si tratta, quindi, solo di riconoscere nuove forme di autorialità nel cloud computing per produrre spimes e strutturare gruppi allargati e flessibili di produzione, ma progettare per le nuove forme organizzative, usando flessibilità e negoziazione come forme espressive e il networking sui server di progettazione come strumento operativo.

Per passare dal solipsistico parametric modeling al "parametric being".

Seconda relazione parte 3 (ultima)

Seconda relazione parte 3 (ultima)

 

Francesca Bottaro: Biblioteca

Il lavoro svolto da Francesca è un esempio di come un progetto già sviluppato viene influenzato dall’uso di REVIT. Come più volte sottolineato da Converso il package REVIT lavora per oggetti, oggetti che sono organizzati in un Data Base.

 Il prossimo corso guadagnerebbe in chiarezza se ai discenti verranno forniti i rudimenti sui Data Base: cosa sono ? Perché il loro uso ha rivoluzionato molti settori dell’economia ? Mi risulta che ai discenti della nostra facoltà non viene somministrato alcun corso relativo ai Data Base.

L’innesto di REVIT nel progetto di Francesca ha messo in evidenza punti di forza e punti di debolezza. L’oggetto “Biblioteca” ha subito una profonda trasformazione dopo l’introduzione dell’energia elettrica come medium illuminotecnico.

Sarebbe una esercitazione interessante progettare una biblioteca che non utilizza l’energia elettrica per fornire i device illuminanti (solo l’illuminazione solare per la lettura) e nel seguito trasformare la biblioteca introducendo device che sono alimentati da energia elettrica.  

I tentativi per l’uso di un curtain wall ha messo in luce i limiti dei modi di pensare l’architettura praticati dai discenti. REVIT semplicemente bandisce l’uso pittorico del discorso architettonico, non lo ammette come strumento di progettazione; REVIT impone, di volta in volta, l’uso di famiglie di oggetti da un menù di famiglie parametrizzate, ovvero REVIT assume che il progettista conosca nei dettagli le varie opzioni relative ad un curtain wall, ovvero assume che il progettista conosca di quali componenti un curtain wall è composto, come si dimensionano, e come si montano: nulla di arbitrario. Quindi fare architettura equivale a giocare con la scatola delle costruzioni ?

Nulla di più lontano dalla realtà. Purtroppo la nostra Facoltà è ambigua al riguardo e non si sforza di “disambiguare” l’agire della disciplina architettonica. Molte volte ho visto i discenti navigare nel WEB, copiare immagini di una costruzione assemblata in qualche punto del nostro pianeta e riproporla al docente, con qualche modifica, durante il corso immaginando di aver compreso l’edificio semplicemente dopo aver guardato alcune foto ed eventuali piante.

Tale modo di fare mi suggerisce che il discente non ha capito un acca della disciplina “architettura”. A parte il fatto che senza una ispezione diretta del manufatto nessuna persona è in grado di comprendere il manufatto stesso, l’esame della sola documentazione tecnica aiuta ad iniziare una riflessione sul manufatto. La disciplina architettonica è processo (ideativo, normativo, costruttivo, ecc.),  prodotto (cantiere, fondazioni, infrastrutture, edifico a vista diretta, ecc) ed uso del manufatto architettonico (quali popolazioni lo usano, come lo usano, quando lo usano, quali futuri usi sono previsti, ecc.). Per semplificare il discorso non accenno al contesto nel quale il manufatto è stato ideato e collocato, argomento sul quale sono stati scritti migliaia di volumi.

Guardare alla singola foto di un manufatto è equivalente a considerare una singola strada nel contesto urbano ed equivale a guardare ad un singolo pixel di una immagine: si commette lo stesso errore!

Tornando all’esempio della nostra biblioteca una buona scelta didattica consiste nell’elencare cosa è vietato e cosa è permesso in una biblioteca, come utilizzare la luce solare senza incappare nell’abbaglio (il prof. Bianchi insegna che leggere un testo con la luce solare diretta equivale a rovinarsi gli occhi ed a rovinare il teso), come integrare funzioni contrapposte nello stesso ambiente. In una biblioteca la lettura dei testi impone zone di silenzio quasi assoluto, zone ove i libri vengono consultati “spot” e zone attrezzate per leggere le riviste (zone con brusio ammesso), zone attrezzate per consultare i cataloghi e chiedere aiuto ai bibliotecari (zone con parlato ammesso). Progettare queste zone è un esercizio astratto e tale fase richiede l’uso di strumenti matematici astratti (grafi, diagrammi, concept, ecc.). I discenti quindi devono essere abituati all’uso di questi strumenti matematici e devono comprendere che la progettazione parametrica è lo strumento adatto, l’unico che permette al progettista di passare dalla fase astratta ai prototipi di manufatti architettonici.

 

Un altro aspetto importante affrontato da Francesca è l’arredo della biblioteca, al riguardo ha usato istanze di famiglie disponibili ed ha fatto esperienza delle loro potenzialità e dei loro limiti cercando di adattarle al contesto da lei progettato. Purtroppo non ha considerato la gerarchia imposta dalle funzioni.

Elenco in ordine di importanza decrescente le funzioni: conservazione dei testi e del materiale vario, lettura, condizionamento per le persone, consultazione dei testi e degli archivi, prestito e restituzione. Ebbene a parte le sedie di cui abbiamo a disposizione una lista infinita una biblioteca richiede un arredo fatto su misura ben diverso da quello utilizzato in un negozio, arredo che deve soddisfare vincoli di budget e vincoli illuminotecnici, arredo che deve permettere l’uso di strumenti classici (la penna ed i fogli per le note) e strumenti informatici (pc, scanner, stazioni di lavoro multimediali). L’arredo ed i corpi illuminanti devono essere robusti e funzionali, l’aspetto estetico ha bassa priorità nella scelta del progettista ed i vincoli visivi restringono le scelte possibili. Colori sgargianti, superfici riflettenti, strutture sghembe e strutture che producono riverbero acustico devono essere bandite: i discenti possono immaginare un biblioteca come una chiesa laica, uno spazio dove le conoscenza è prodotta.

 

Miguel Reyna :Parapetto rigato

Per questo progetto Miguel ha utilizzato il package Grasshopper plugin gratuito di Rhinoceros; questo package ha una interessante interfaccia grafica ma ovviamente questo non basta a rendere più facile lo sviluppo di un progetto. L’obiettivo di Miguel era assemblare un prototipo in scala di un parapetto utilizzando una macchina a controllo numerico per il taglio di alcuni componenti. Tre errori hanno obbligato Miguel a svolgere un lavoro continuo di rettifica sul programma preparato con Grasshopper; il primo errore è stato un errore di metodo, il secondo un errore di errata previsione della forma di alcuni componenti (le strisce) , il terzo errore è stato causato dalla mancata conoscenza delle fasi di assemblaggio che un parapetto richiede.

 

Partiamo da questo ultimo errore. La forma molto interessante proposta per il parapetto richiede l’uso dell’acciaio quale materiale costruttivo, legno ed altri materiali sintetici devono essere esclusi in quanto un parapetto è una barriera che deve prevenire cadute accidentali. Le “strisce” saranno quindi ricavate dal taglio di una bandella flessibile, la bandella verrà saldata alla componente “attacco a terra” del parapetto, tale componente verrà chiamato base per comodità e nel caso reale sarà costituita da uno scatolare in acciaio, di sezione rettangolare, ancorato a terra.

La base non richiede parametrizzazione essendo la sua forma rettilinea, la distribuzione degli attacchi tra la base e le strisce (saldate nel caso reale) è stata giustamente parametrizzata per avere a disposizione gradi di libertà sulla forma del parapetto. Per scelta del progettista gli incastri tra bandelle e base sono paralleli all’asse longitudinale della base. Il corrimano del parapetto è di forma ondulata e per eseguire l’ancoraggio tra le strisce ed il corrimano nel caso reale dovranno essere praticati tagli passanti che accolgono la bandella (le strisce). La bandella verrà saldata alla faccia inferiore e superiore del corrimano ondulato, le successive operazioni di levigatura, pulitura e trattamento delle superfici interessano solo per la stima del costo totale del parapetto. La distribuzione dei tagli passanti del corrimano è stata correttamente parametrizzata ed è stata introdotta la rotazione delle bandelle tra la base ed il corrimano.

Veniamo al primo errore: errore di metodo. Miguel doveva semplicemente descrivere il suo design usando poche equazioni matematiche: la distribuzione degli incastri alla base, la forma del corrimano, il suo posizionamento nello spazio, la distribuzione dei tagli nel corrimano. Con semplici metodi di geometria analitica in 3D avrebbe definito un set di equazioni parametriche delle entità sinora descritte, entità che Miguel ha cercato di rappresentare utilizzando un package non adeguato, sovradimensionato rispetto il suo obiettivo, ovvero Grasshopper. Utilizzando semplice geometria analitica ed un semplice programma di calcolo come excel avrebbe, con poche ore di lavoro definito la lista dei componenti da tagliare, la posizione delle asole ed evrebbe eviato di commettere il secondo errore.

Le coordinate degli estremi delle asole che accolgono una singola bandella, senza bisogno di descrivere analiticamente la curva che i lati lunghi della bandella forma nello spazio quando viene “torta”avrebbero evidenziato la impossibilità di usare un nastro non elastico nel prototipo in scala che Miguel voleva assemblare.

Concludo questa relazione ricordando che il primo strumento che deve essere utilizzato quando si vuole sviluppare un design parametrico è la matematica, ovvero la piattaforma più potente che abbiamo a disposizione.

Pagine

Theme by Danetsoft and Danang Probo Sayekti inspired by Maksimer