Mazzocchio

[marcomasetti]

Mi capitò a scuola di chiamare alla lavagna uno dei miei allievi più indisciplinati, o se vogliamo più cretinetti, e gli dissi di disegnarmi un toro. Quel somaro disegnò allora un erbivoro come lui, ma con le corna.
In questo topic descrivo la costruzione della primitiva di un toro, questa volta senza corna.   Paolo Uccello chiamava questo tipo di superficie mazzocchio.   Il pittore passava ore ed ore, rimanendo pure sveglio la notte, per studiare come realizzarne le vedute prospettiche esatte.  L’artista elaborò anche vari modi per suddividere la sfera e per aggiungervi punte. Se avesse avuto un calcolatore, avrebbe ottenuto subito i risultati, ma la sua arte avrebbe perso il fascino.   Certi momenti storici sono irripetibili.  Per il mondo di oggi circoleranno molti cervelli paragonabili a quello di Leonardo, ma nessuno dipingerà qualcosa di simile alla Gioconda.  Il simbolo del mondo odierno è piuttosto l’orinatoio di Duchamp.   Comunque la geometria non può essere separata dall’arte, a meno che non diventi filosofia, come per le ultime opere di Duchamp. Anche in questo caso, comunque, si filosofeggia sulla geometria, perché anche un orinatoio o una ruota di bicicletta sono forme geometriche.
Il toro viene generato da un cerchio generatore che ruota lungo un asse appartenente al suo piano.
Tale asse dovrebbe essere esterno al cerchio.  Sia r2 il raggio del cerchio generatore, mentre sia r1 la distanza dal centro di tale cerchio all’asse di rotazione. Dovrebbe essere r1>=r2.
Per costruire il toro cominciamo a descrivere la sezione generatrice posta sul piano xz. Come asse di rotazione scegliamo l’asse coordinato z.
I vertici di tale circonferenza sono definiti dalla formula (1):
for i=0 to m-1
al=360/m*i
xp= r1+r2*cos(al)
zp= r2*sin(al)
VERT  xp,  0 ,  zp
next i

Ricordo che anche per scrivere un cerchio 2D di raggio r2 usiamo la formula:
for i=0 to m-1
an=360/m*i
PUT  r2*cos(an) ,  r2*sin(an)
next i
poly2 nsp/2, 1+4, get (nsp)    !1: mostra segmenti; 4: chiudi poligono

L’equazione parametrica della circonferenza di raggio r2 è infatti:
x= r2*cos(an)
y= r2*sin(an)
con an definito entro l’intervallo [0,360)

Poiché in 3D il centro del cerchio è in  (r1, 0, 0) occorre aggiungere r1 alla prima coordinata, operazione equivalente a:
ADD r1

La rotazione di un punto P di coordinate (xp,0,zp), che risulta ovviamente giacente su xz, si esprime con le equazioni parametriche:
x=xp*cos(az)
y=xp*sin(az)
z=zp
con az definito entro l’intervallo [0,360)

Tale sistema esprime infatti una circonferenza di raggio xp, posta a quota zp, con centro sull’asse z.
Pertanto la (1) diventa l’espressione seguente (2):

n=   !lati poligono direttore    (circonferenza maggiore)
m=  !lati poligono generatore (circonferenza sezione verticale)

for j=0 to n-1
az=360/n*j
for i=0 to m-1
al=360/m*i
xp= r1+r2*cos(al)
zp= r2*sin(al)
VERT  xp*cos(az),  xp*sin(az) ,  zp
next i
next j

Nella fase successiva occorre scrivere i segmenti che collegano I punti.
I primi m punti rappresentano i vertici della prima sezione. Il primo punto va collegato al successivo e così via. L’ultimo punto della sezione va però ricollegato al primo.
Per cui l’elenco degli m segmenti della sezione iniziale su xz è:
for i=1 to m-1
EDGE   i ,  i+1,        -1,-1,s
next i
EDGE  m , 1, -1,-1,s

Per passare alla sezione successiva occorre aggiungere m agli indici dei vertici:
for i=1 to m-1
EDGE   i+m ,  i+1+m,        -1,-1,s
next i
EDGE  m+m , 1+m, -1,-1,s

Per arrivare alla sezione j.ma occorre aggiungere j*m agli indici dei vertici:
for i=1 to m-1
EDGE   i+j*m ,  i+1+j*m,        -1,-1,s
next i
EDGE  m+j*m , 1+m, -1,-1,s

Poichè le sezioni sono n, occorre variare j tra 1 e n, oppure tra 0 e n-1, così la prima sezione corrisponde a quella iniziale:
for j=0 to n-1
for i=1 to m-1
EDGE i+j*m,i+1+j*m,-1,-1,s
next i
EDGE i+j*m,1+j*m,-1,-1,s
next j

Per realizzare i ponti orizzontali tra le sezioni, occorre saltare da una sezione a quella successiva, il cui indice cresce rispettivamente di m:  da i si deve passare a i+m. L’ultima sezione si deve pero ricollegare alla prima, per cui si dovrà scrivere:
for j=0 to n-2  !sezioni da 1 a n
for i=1 to m
EDGE i+j*m,i+j*m+m,-1,-1,s
next i
next j
for i=1 to m  !ultima sezione
EDGE i+(n-1)*m,i,-1,-1,s
next i

A questo punto si possono visualizzare in 3D gli EDGES per vedere se la costruzione è corretta, poi bisogna costruire i poligoni PGON. Per farlo si sceglie la risoluzione più bassa: m=3 e n=3.
Si realizza uno schizzo su un foglio, numerando con colori diversi i vertici e i segmenti orientati o EDGES, con segnato il verso relativo. Si parte dal primo PGON poi si ragiona sul salto che compiono gli EDGES sia nel passare alla parte superiore dello stesso anello, che nel passare all’anello successivo.  Occorre anche ricordare che l’ultimo elemento di un anello si ricollega al primo, per cui lo script va frazionato come si è fatto per gli EDGES.  Se si vuole costruire una superficie deformabile a piacere occorre introdurre gli EDGES obliqui e scomporre i PGON quadrilateri in due PGON a tre lati. Occorre ricordare che due PGON adiacenti hanno l’EDGE in comune che segue sensi opposti: ora sarà negativo poi positivo.

for j=0 to n-2  !n-1 anelli verticali
for i=1 to m-1 !m-1 poligoni quadrilateri di un anello verticale j
PGON 4,0,-1,-(m*n+1+i+m*j),-(i+m*j),m*n+i+m*j,m+i+m*j
next i
!segue ultimo poligono quadrilatero che si ricollega al primo dell’anello j
PGON 4,0,-1,-(m*n+1+m*j),-(m+m*j),m*n+i+m*j,m+i+m*j
next j

j=n-1 !sezione di chiusura
for i=1 to m-1
PGON 4,0,-1,-(m*n+1+i+m*j),-(i+m*j),m*n+i+m*j,i
next i
PGON 4,0,-1,-(m*n+1+m*j),-(m+m*j),m*n+i+m*j,i
!i valori i corrispondono ai primi segmenti verticali che chiudono gli ultimi poligoni


Consideriamo ora la possibilità di applicare deformazioni al toro (nella versione cstruita con face triangolari).
Osserviamo anzitutto come l’espressione (2) che definisce i vertici del toro possa essere riscritta:

for j=0 to n-1
for i=0 to m-1
xp= r1+r2*cos(360/m*i)
zp= r2*sin(360/m*i)
x= xp*cos(360/n*j)
y= xp*sin(360/n*j)
z= zp
VERT  x,y,z
next i
next j

I valori xp,zp dipendono dalla variabile i, ma potrebbero anche dipendere dalla variabile j: in questo modo potrebbe cambiare la forma delle diverse sezioni.    Naturalmente perché il toro deformato si chiuda correttamente dovrebbe risultare:
xp(i,0)= xp(i,n)  e   yp(i,0)= yp(i,n)   per ogni i compreso tra 0 e m-1.
In questo modo la forma dell’ultima sezione m (esclusa dallo script) coinciderebbe con la forma della prima.
Inoltre le funzioni che definiscono il singolo anello devono avere pure coincidenti il punto iniziale e finale, per non avere salti bruschi:
xp(0,j)= xp(m,j)  e   yp(0,j)= yp(m,j)   per ogni j compreso tra 0 e n-1.
I valori x,y,z a loro volta dipendono xp,zp, j.
Anche qui si potrebbe usare qualsiasi funzione da R^3 a R^3 (cioè a tre variabili in entrata e in uscita), purchè:
x (xp,yp,0)= x (xp,yp,n),   y (xp,yp,0)= y (xp,yp,n),  z (xp,yp,0)= z (xp,yp,n)
La forma generalizzata dei vertici del toro allora diventa:

for j=0 to n-1
for i=0 to m-1
xp= xp(i,j)
zp= zp(i,j)
x=x (xp,yp,j)
y= x(xp,yp,j)
z=x(xp,yp,j)
VERT  x,y,z
next i
next j

Come esempio di deformazione, scelgo come curva trasversale una linea polare composta a forma di pera:
r=    .5   !raggio pera
r1=   .4  !diagonale strozzatura
an=  50 !angolo diagonale strozzatura
r2=   .9 !altezza superiore
r3=  .3  !altezza inferiore
m=  16 ! resol
r0=  1.5 !offset centro=raggio rotazione

put r0+r3*(1+o*cos(360/n*j*k) ),0

for i=1 to m-1

al=360/m*i
n1=90/360*m
x1=r3*cos(i*90/n1)*(sgn(al)-(sgn(al-90)))/2
y1=  r*sin(i*90/n1)*(sgn(al)-(sgn(al-90)))/2
n2=an/360*m
x2= ((r+r1)/2+(r-r1)/2*cos((i-n1+1)/n2*180))*cos(90+(i-n1+1)*an/n2)*(sgn(al-90)-(sgn(al-90-an)))/2
y2= ((r+r1)/2+(r-r1)/2*cos((i-n1+1)/n2*180))*sin(90+(i-n1+1)*an/n2)*(sgn(al-90)-(sgn(al-90-an)))/2
n3=(90-an)/360*m
x3= ((r2+r1)/2-(r2-r1)/2*cos((i-n1-n2+1)/n3*180))*cos(90+an+(i-n1-n2+1)*(90-an)/n3)*(sgn(al-90-an)-(sgn(al-180)))/2
y3= ((r2+r1)/2-(r2-r1)/2*cos((i-n1-n2+1)/n3*180))*sin(90+an+(i-n1-n2+1)*(90-an)/n3)*(sgn(al-90-an)-(sgn(al-180)))/2
n3=(90-an)/360*m
x4= ((r2+r1)/2-(r2-r1)/2*cos((n3-(i-n1-n2-n3+1))/n3*180))*cos(90+an+(n3-(i-n1-n2-n3+1))*(90-an)/n3)*(sgn(al-180)-(sgn(al-270+an)))/2
y4=-((r2+r1)/2-(r2-r1)/2*cos((n3-(i-n1-n2-n3+1))/n3*180))*sin(90+an+(n3-(i-n1-n2-n3+1))*(90-an)/n3)*(sgn(al-180)-(sgn(al-270+an)))/2
n2=an/360*m
x5= ((r+r1)/2+(r-r1)/2*cos((n2-(i-n1-n2-2*n3+1))/n2*180))*cos(90+(n2-(i-n1-n2-2*n3+1))*an/n2)*(sgn(al-270+an)-(sgn(al-270)))/2
y5=-((r+r1)/2+(r-r1)/2*cos((n2-(i-n1-n2-2*n3+1))/n2*180))*sin(90+(n2-(i-n1-n2-2*n3+1))*an/n2)*(sgn(al-270+an)-(sgn(al-270)))/2
n1=90/360*m
x6= r3*cos((n1-(i-n1-2*n2-2*n3+1))*90/n1)*(sgn(al-270)-(sgn(al-360)))/2
y6= -r*sin((n1-(i-n1-2*n2-2*n3+1))*90/n1)*(sgn(al-270)-(sgn(al-360)))/2

xp= r0+(x1+x2+x3+x4+x5+x6)*(1+o*cos(360/n*j*k) )
zp= (y1+y2+y3+y4+y5+y6) *(1+o*cos(360/n*j*k) )

x= xp*cos(360/n*j)
z= zp*(1+o*cos(360/n*j*k) )

put  x,z
next i

poly2 nsp/2, 1  , get(nsp)

Da notare che questa curva assume forma regolare solo per risoluzioni molto alte, vicino a 100.
L'ho scelta soltanto perché è un esempio di curve polari raccordate, ma ci sono curve polari a pera più semplici e più adatte.
Lo script dei vertici diventa:

for j=0 to n-1

xp=r0+r3*(1+o*cos(360/n*j*k) )
VERT  xp*cos(360/n*j),xp*sin(360/n*j),0

for i=1 to m-1

al=360/m*i
n1=90/360*m
x1=r3*cos(i*90/n1)*(sgn(al)-(sgn(al-90)))/2
y1=  r*sin(i*90/n1)*(sgn(al)-(sgn(al-90)))/2
n2=an/360*m
x2= ((r+r1)/2+(r-r1)/2*cos((i-n1+1)/n2*180))*cos(90+(i-n1+1)*an/n2)*(sgn(al-90)-(sgn(al-90-an)))/2
y2= ((r+r1)/2+(r-r1)/2*cos((i-n1+1)/n2*180))*sin(90+(i-n1+1)*an/n2)*(sgn(al-90)-(sgn(al-90-an)))/2
n3=(90-an)/360*m
x3= ((r2+r1)/2-(r2-r1)/2*cos((i-n1-n2+1)/n3*180))*cos(90+an+(i-n1-n2+1)*(90-an)/n3)*(sgn(al-90-an)-(sgn(al-180)))/2
y3= ((r2+r1)/2-(r2-r1)/2*cos((i-n1-n2+1)/n3*180))*sin(90+an+(i-n1-n2+1)*(90-an)/n3)*(sgn(al-90-an)-(sgn(al-180)))/2
n3=(90-an)/360*m
x4= ((r2+r1)/2-(r2-r1)/2*cos((n3-(i-n1-n2-n3+1))/n3*180))*cos(90+an+(n3-(i-n1-n2-n3+1))*(90-an)/n3)*(sgn(al-180)-(sgn(al-270+an)))/2
y4=-((r2+r1)/2-(r2-r1)/2*cos((n3-(i-n1-n2-n3+1))/n3*180))*sin(90+an+(n3-(i-n1-n2-n3+1))*(90-an)/n3)*(sgn(al-180)-(sgn(al-270+an)))/2
n2=an/360*m
x5= ((r+r1)/2+(r-r1)/2*cos((n2-(i-n1-n2-2*n3+1))/n2*180))*cos(90+(n2-(i-n1-n2-2*n3+1))*an/n2)*(sgn(al-270+an)-(sgn(al-270)))/2
y5=-((r+r1)/2+(r-r1)/2*cos((n2-(i-n1-n2-2*n3+1))/n2*180))*sin(90+(n2-(i-n1-n2-2*n3+1))*an/n2)*(sgn(al-270+an)-(sgn(al-270)))/2
n1=90/360*m
x6= r3*cos((n1-(i-n1-2*n2-2*n3+1))*90/n1)*(sgn(al-270)-(sgn(al-360)))/2
y6= -r*sin((n1-(i-n1-2*n2-2*n3+1))*90/n1)*(sgn(al-270)-(sgn(al-360)))/2

xp= r0+(x1+x2+x3+x4+x5+x6)*(1+o*cos(360/n*j*k) )
zp= (y1+y2+y3+y4+y5+y6) *(1+o*cos(360/n*j*k) )

x= xp*cos(360/n*j)
y= xp*sin(360/n*j)
z= zp*(1+o*cos(360/n*j*k) )

VERT  x,y,z

next i
next j

La parte   (1+o*cos(360/n*j*k) )  con k intero aumenta e riduce la sezione nella parte applicata a xp,zp, mentre  fa salire e scendere di quota nella parte applicata a z.
Adesso andiamo a vedere il risultato in:
toro prim es1.gsm
La forma è un anello trilobato irregolare.
Come si vede il calcolatore non ha alcuna difficoltà nell’interpretare le formule più complesse.

Come ho scritto nell’ultimo topic, concordo con zio Bob: le formule sono fatte per essere tradotte in immagini. Questo l’ho fatto inserendo alcune immagini in due blog:
http://oggettigeometricigdl.wordpress.com/
http://marcomasettiprospettico.wordpress.com/

La questione è che quando mi girano idee per la zucca, devo tradurle, prima che svaniscano.  Come ho scritto, se qualcuno vuole divertirsi anche a creare filmati, ad esempio utilizzando il labirinto di Peano, mi farebbe piacere. Partecipo per condividere e la condivisione richiede partecipazione.   Basta usare gli oggetti già pronti e inserire i parametri.