Rettangolo con sottomoduli

[marcomasetti]

Vogliamo applicare ad una scacchiera, cioè ad un rettangolo suddiviso in moduli quadrangolari, una trasformazione dello spazio del tipo:
x’=x’(x,y,z)
y’=y’(x,y,z)
z’=z’(x,y,z)
La trasformazione potrebbe essere una omologia tridimensionale, ovvero una prospettiva curva 3D.
Per ottenere questo risultato occorre suddividere il modulo quadrangolare in sottomoduli, così che potrà essere incurvato secondo la deformazione spaziale rappresentata dal sistema di equazioni.
Per prima cosa costruiamo una forma primitiva piana costituita da una scacchiera di lati lx,ly con nx moduli quadrangolari lungo x e ny moduli quadrangolari lungo y:
lx=
ly=
nx=
ny=
for j=0 to ny
for i=0 to nx
VERT  i*lx/nx,  j*ly/ny,  0
next i
next j

for j=0 to ny
for i=1 to nx
EDGE i+j*(nx+1), i+1+j*(nx+1),-1,-1,0
next i
next j !// asse x, da sin a dex

for j=0 to ny-1
for i=1 to nx+1
EDGE i+j*(nx+1), i+nx+1+j*(nx+1),-1,-1,0
next i
next j !// asse y, da basso a alto

for j=0 to ny-1
for i=1 to nx
if (-1)^(i+j)=1 then material m1 else material m2
PGON 4, 0, -1, i+j*nx,nx*(ny+1)+i+1+j*(nx+1),-(i+nx+j*nx),-(nx*(ny+1)+i+j*(nx+1))
next i
next j
(vedi oggetto:   rect modulare prim.gsm)

Notiamo che (-1)^(i+j) vale 1 quando la somma di i e j assume un valore pari, per cui vengono alternati i materiali con indice m1 e m2.
In questo caso sono ammesse solo trasformazioni che non incurvano i singoli poligoni quadrangolari, che devono rimanere piani. Ad esempio possono essere applicate trasformazioni proiettive (lineari),o trasformazioni che incurvano  il piano a cilindro.
Per avere la possibilità di incurvare il reticolo a piacimento occorre introdurre edges diagonali e si devono sostituire i poligoni quadrangolari con triangoli:
for j=0 to ny
for i=0 to nx
VERT  i*lx/nx,  j*ly/ny,  0
next i
next j

for j=0 to ny
for i=1 to nx
EDGE i+j*(nx+1), i+1+j*(nx+1),-1,-1,0
next i
next j !// asse x, da sin a dex,#=nx*(ny+1)

for j=0 to ny-1
for i=1 to nx+1
EDGE i+j*(nx+1), i+nx+1+j*(nx+1),-1,-1,0
next i
next j !// asse y, da basso a alto,#=ny*(nx+1),subtot=2*nx*ny+nx+ny

for j=0 to ny-1
for i=1 to nx
EDGE i+j*(nx+1), i+nx+2+j*(nx+1),-1,-1,0
next i
next j !obliqui, da basso a alto,#=ny*nx,tot=3*nx*ny+nx+ny

for j=0 to ny-1
for i=1 to nx
if (-1)^(i+j)=1 then material m1 else material m2
PGON 3, 0, -1, i+j*nx,nx*(ny+1)+i+1+j*(nx+1),-(2*nx*ny+nx+ny+i+j*nx)
PGON 3, 0, -1, 2*nx*ny+nx+ny+i+j*nx,-(i+nx+j*nx),-(nx*(ny+1)+i+j*(nx+1))
next i
next j
(vedi oggetto:   rect modulare prim2.gsm)

Infine occorre avere la possibilità di suddividere ogni quadrangolo della scacchiera in un numero n arbitrario di parti: n sarà allora il valore di risoluzione con cui il poliedro si approssima alla superficie curva generata dalla trasformazione dello spazio.
Per ottenere il risultato, invece di suddividere in sottoparti la scacchiera, costruiamo una nuova scacchiera servendoci dell’ultimo script sostituendo sia nx che ny con n, ponendo poi lx=ly=l.
Avremo così un modulo primitivo quadrato suddiviso in n*n quadratini di lato l/n.
A questo punto iteriamo il modulo quadrato così ottenuto nx volte lungo x e ny volte lungo y.
Il risultato sarà un reticolo, non primitivo, composto di nx*ny moduli quadrati primitivi di lato l.
La lunghezza del reticolo lungo x sarà nx*l , mentre lungo y la lunghezza sarà ny*l.
Lo script ricercato sarà:
for w=0 to ny-1
for k=0 to nx-1
BASE
for j=0 to n
for i=0 to n
VERT   i*l/n+l*k,   j*l/n+l*w, 0
next i
next j

for i=1 to n
EDGE i, i+1,-1,-1,0
next i
for j=1 to n-1
for i=1 to n
EDGE i+j*(n+1), i+1+j*(n+1),-1,-1,j1
next i
next j
for i=1 to n
EDGE i+n*(n+1), i+1+n*(n+1),-1,-1,0
next i !// asse x

for j=0 to n-1
EDGE 1+j*(n+1), n+2+j*(n+1),-1,-1,0
for i=2 to n
EDGE i+j*(n+1), i+n+1+j*(n+1),-1,-1,j1
next i
EDGE n+1+j*(n+1), 1+2*n+1+j*(n+1),-1,-1,0
next j !// asse y

for j=0 to n-1
for i=1 to n
EDGE i+j*(n+1), i+n+2+j*(n+1),-1,-1,j1
next i
next j !obliqui

for j=0 to n-1
for i=1 to n
if (-1)^(k+w)=1 then material m1 else material m2
PGON 3, 0, -1, i+j*n,n*(n+1)+i+1+j*(n+1),-(2*n*n+n+n+i+j*n)
PGON 3, 0, -1, 2*n*n+n+n+i+j*n,-(i+n+j*n),-(n*(n+1)+i+j*(n+1))
next i
next j
BODY -1
next k
next w
(vedi oggetto:   rect modulare prim3.gsm)


Consideriamo la trasformazione dello spazio:
xx=xx(x,y,z)
yy=yy(x,y,z)
zz=zz(x,y,z)
dove xx,yy,zz sono rispettivamente funzioni a tre variabili in x,y,z.
Se vogliamo applicare questa trasformazione alla scacchiera, lo script dei vertici diventa:
for j=0 to n
for i=0 to n
x= i*l/n+l*k
y= j*l/n+l*w
xx=xx(x,y,0)
yy=yy(x,y,0)
zz=zz(x,y,0)
VERT xx,yy,zz
next i
next j

Nei commenti degli oggetti GDL allegati si trovano gli script anche per i piani paralleli ai piani coordinati xz e yz.