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
Piastrella in terracotta, rivestimento di facciata esterna 6 anni 3 mesi fa 14 anni 6 giorni fa Immagine, Piastrella di terracotta, Projects, Tecniche Parametriche Arbjona Koxhaj
Finestra 2 ante-60 6 anni 3 mesi fa 14 anni 6 giorni fa Finestra, Immagine, Projects, Tecniche Parametriche Julian Bala
Finestra 2 ante-70 6 anni 3 mesi fa 14 anni 6 giorni fa Finestra, Immagine, Projects, Tecniche Parametriche Julian Bala
Finestra 2 ante-80 6 anni 3 mesi fa 14 anni 6 giorni fa Finestra, Immagine, Projects, Tecniche Parametriche Julian Bala
Finestra 2 ante 6 anni 3 mesi fa 14 anni 6 giorni fa Finestra, Immagine, Projects, Tecniche Parametriche Julian Bala
Finestra 2 ante 6 anni 3 mesi fa 14 anni 6 giorni fa Finestra, Immagine, Projects, Tecniche Parametriche Julian Bala
Finestra 2 ante 6 anni 3 mesi fa 14 anni 6 giorni fa Finestra, Immagine, Projects, Tecniche Parametriche Julian Bala
gradino 6 anni 3 mesi fa 14 anni 5 giorni fa Immagine ValentinaDelVescovo
2_famiglie gradino 6 anni 3 mesi fa 14 anni 5 giorni fa Immagine ValentinaDelVescovo
3_parametrogradino 6 anni 3 mesi fa 14 anni 5 giorni fa Immagine ValentinaDelVescovo

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

Parametrizzazione del parapetto rigato

In questo post intendo mostrare come ho portato avanti il lavoro di parametrizzazione del parapetto rigato. Rispetto a post precedente (http://design.rootiers.it/node/566), ho apportato alcune modifiche, partendo dalla seconda delle due opzioni: innanzitutto sono stati inseriti dei montanti verticali, presenti in ogni intersezione in pianta tra la curva del corrimano e l'attacco lineare a terra. Inoltre, per ridurre lo spazio tra gli elementi verticali (per problemi normativi) senza restringere troppo la larghezza delle fasce ne ho cambiato il "pattern": adesso sia l'elemento superiore che l'elemento inferiore alternano attacchi lungo l'asse a attacchi ortogonali all'asse.le superfici partono da un attacco disposto in una direzione e arrivano a un attacco disposto nell'altra.

Il modello è finalizzato a produrre i disegni da inserire nella macchina a controllo numerico per effettuare un plastico in scala 1:5, quindi le fascie non si attaccano ad elementi metallici.

Il lavoro è stato portato avanti usando Grasshopper, un plugin gratuito di Rhinoceros. Per capire il funzionamento del programma mi è stato molto utile un libro digitale freeware di ZUBIN KHABAZI, GENERATIVE ALGORITMS using GRASSHOPPER, che tra l'altro tratta anche di applicazioni architettoniche.

La strada che ho seguito è indubbiamente lunga, sia perchè sicuramente ci sono modi molto piu rapidi di fare le stesse cose, ma anche perchè ho provato a fare un modello il più generico possibile, in modo da poter modificare i diversi parametri.

Grasshopper funziona un pò diversamente da Revit, la sua interfaccia è formata da uno spazio infinito al cui interno inserire dei componenti, che hanno l'aspetto di rettangoli grigi. I componenti possono essere legati a geometrie disegnate o meno, e possono essere dei  più diversi tipi (trasformazioni, elementi matematici, curve, ecc); hanno tutti degli imput (i bottoncini a sinistra in cui arrivano i cavi) e degli output (i bottoncini a destra da cui partono); i tipi di imput e di output variano da componente a componente. Collegando tra di loro i componenti si trasforma la geometria finale.

Gli unici elementi disegnati manualmente in Rhino sono gli assi del corrimano e dell'atacco a terra. Ho incominciato disegnandoli entrambi sullo stesso piano. Da Grasshopper ho inserito due curve (params>geometry>curve) e gli ho detto di collegarle ognuna a una curva da me disegnata (tasto destro sul componente curva>set one curve). Adesso le curve fanno parte di Grasshopper, e posso cambiare modificarale dal programma a mio piacimento.
In ogni pezzo di parapetto tra montante e montante lo spazio tra le fasce varierà, lasciando invariata la lunghezza dell'attacco cambierà un pò la distanza tra attacco e attacco, assorbendo le diverse e casuali lunghezze della curva. E' quindi impotante dividere la curva in pezzi diversi in modo che in ogni pezzo venga trovata la distanza giusta.
Con il componente Curve/curve (intersect>Physical>Curve/curve) trovo le intersezioni tra le due curve, quindi sposto verticalmente la curve e i punti di intersezione trovati. Lo faccio con il comando move (XForm> Euclidean move), e usando come vettore il vettore z (vector>Unit z); l'intensità dello spostamento è regolata da uno slider, cioè un elemento che può essere regolato manualmente tra due valori numerici definiti dall'utente.

A questo punto devo trovare la "zona di influenza" dei montanti, cioè i punti a partire dai quali posso incominciare a lavorare sui singoli pezzi di parapetto. Lo faccio spostando i punti lungo la curva attravero il vettore tangente. In questo caso potrei anche spostarli tutti dando la stessa direzione, ma nella curva del corrimano no, questo modo e valido anche per la curva di sopra. Il vettore tangente nelle intersezioni lo trovo col componente Evaluate Curve (Curve>Analisis>Evaluate Curve), e moltiplicato per una distanza regolata da uno slider mi serve come vettore per lo spostamento (move) dei punti.Ho aggiunto uno slider con valore -1 in modo da spostare il secondo punto della stessa quantità ma in direzione opposta; infine ho unito i punti spostati collegandoli al componente point (Params>Geometry>Point)

A questo punto ho avuto problemi a suddividere la curva nei punti indicati; riesco a suddividere una curva solo rispetto ad altre curve. Quindi ho spostato di poco i punti da un lato e dall'altro e li ho uniti con il componente Line (Curve>primitive>line); poi ho intersecato la linea iniziale con le altre piccole linee. Adesso basterebbe dividere la curva nei parametri (tA) dell'intersezione. C'è però un problema di tipologia di dati, riguardante i cosidetti "data trees"; mentre le informazioni sulla curva sono contenute in un solo "pacchetto" di dati l'intersezione è divisa in diversi pacchetti, come si vede nei diagrammi circolari dell'immagine; per accedere ai diagrammi di un componente bisogna attaccarlo a Param Viewer(Params>Special>Param Viewer)

Grasshopper spesso deve avere gli input nello stesso numero di pacchetti per poter far funzionare i componenti. Uso quindi Flattern tree (Sets>Tree>Flatter Tree), che mi riporta a un solo pacchetto, o ramo, le informzioni dell'intersezione. A questo punto posso procedere con la divisione della curva (Curve>Division>Shatter)
Il risultato della divisione però comprende i pezzi tra i montanti ma anche i pezzi corrispondenti ai montanti stessi; per eliminarli uso come criterio quello della lunghezza, cioè di tutti i pezzi divisi ne seleziono solamente quelli più grandi di una quantità da me definita. Lo faccio usando il componente Cull Pattern (Sets>Sequence>Cull Pattern). Come lista di elementi da rimuovere uso i pezzi di linea suddivisi, e come pattern di selezione uso i pezzi piu grandi del doppio dello spostamento del punto piu 1(Larger Than(Math>Operators>Larger Than))

Procedo adesso a definire le linee parallele all'asse.
Devo dividere la curva in numero di elementi che mi permetta di avere almeno 19 cm tra elemento e elemento. Il numero di elementi è definito dall'equazione
=(lunghezza della curva /21) - 0.5 (affinchè il numero venga arrotondato al intero più piccolo). La lunghezza dei segmenti la ottengo con Lenght (Curve>Analisis>Lenght).


 
Adesso devo spostare i punti da una parte e dall'altra in modo da inquadrare i singoli attacchi che ho stabilito essere di 15 cm. trovo l'intensità dello spostamento con la seguente formula
=(Lunghezza delle curve/n° di volte che sono state divise - 15cm (lunghezza dell'attacco))/2.
La direzione è data dall'output T del componente Divide. Questa volta devo moltiplicare l'output T, che ha diverse ramificazioni col risultato dell'equazione, che ne ha soltanto una. Devo fare l'operazione opposta a quella di Flattern Tree, cioè Graft tree (Sets>Tree>Graft Tree), in modo da poter ramificare i risultati dell'equazione.

Ora devo ridividere i pezzi di curva in maniera da rimanere soltanto con gli attacchi; procedo in maniera simile alla prima divisione: sposto i punti in modo da creare piccole linee che interseco con i pezzi tra montante e montante, e uso per dividere i pezzi stessi; poi escludo i pezzi più piccoli indesiderati con una selezione in base alla lunghezza

Devo adesso disegnare gli attacchi perpendicolari alla curva. Riprendo quindi dal componente cull, ovvero da i pezzi tra montante e montante, che uso come curva base per un offset (Curve>Util>Offset). Uso la stessa formula usata in precedenza per dividere i due pezzi di curva, e unisco i punti della divisione tra di loro

A questo punto ripeto lo stesso procedimento sulla curva del corrimano con alcune accortezze, tra cui quella di dividere i pezzi di curva non secondo equazioni ma rispetto al numero di volte in cui è stata divisa la linea dell'attacco a terra e quella di rendere rettilinei gli attacchi lungo l'asse del corrimano. Abbiamo quindi pronte tutte le linee che useremo come base per le superfici rigate.


Quindi basterà creare superfici incrociando i gruppi di linee. Il tipo di superficie più idoneo è Edge surface(Surface>Freeform>Edge Surface), che a partire da sole 2 linee crea una superficie. Attribuendo le linee c'è però un problema: le linee di sopra si accoppiano male con le linee di sotto, cioè la prima di sopra si accoppia con l'ultima e viceversa; per risolvere il problema c'e bisogno del componente Reverse List (Sets>List>Reverse List) in grado di invertire l'ordine in cui si presentano gli elementi.

Infine ho fatto gli elementi rimanenti (corrimano, montanti, ecc) a partire da alcuni punti caratteristici, spostandoli per creare linee da estrudere successivamente

Adesso per fare un parapetto mi basta selezionare qualsiasi coppia di curve (dalle curve iniziali tasto destro>set one curve) e verranno calcolati automaticamente le posizioni dei montanti e la giusta distanza tra le fasce.

Nel prossimo post scriverò su come preparare i disegni da mandare alla macchina a controllo numerico, anche se a questo punto non credo che riuscirò ad avere il plastico pronto per l'esame

Pagine

Theme by Danetsoft and Danang Probo Sayekti inspired by Maksimer