Realizzare una sinusoide smorzata

[marcomasetti]

La sinusoide è una curva fondamentale nel design.   Sin dall’antichità questa curva è stata utilizzata come motivo decorativo. Ricordiamo che pittori come Hogarth definivano il flesso come la curva della bellezza. Oltre a simboleggiare il moto ondoso è anche una funzione fondamentale per lo studio fisico delle onde.
In questo esercizio intendo descrivere come dalla semplice funzione seno si può passare a curve ondulate più complesse.
La funzione:
y=r*(sin(p*180*x/h))^2           (1)
si ricava dalla curva sinus elevandola al quadrato, in tal modo il periodo passa da 360 a 180 e l’oscillazione varia tra y=0 e y=1.
Se invece si scrivesse:     y=r*abs(sin(p*180*x/h))
si avrebbe una curva simile, ma con cuspidi nei punti di minimo.
Risulta chiaro che la funzione (1) ha oscillazione tra y=0 e y=r, con lunghezza d’onda h/p, per cui nell’intervallo [0,h] si creano p picchi.
La funzione:   y=r*x/h  rappresenta  una retta uscente da O con pendenza r/h, per cui, moltiplicandola per la sinusoide, otteniamo picchi che aumentano in maniera lineare:
y= r*x/h *(sin(p*180*x/h))^2        (2)
La funzione:   y=r-r/h^2*(x-h)^2  rappresenta una parabola diritta, con asse verticale in x=h, che attraversa l’origine O.     Pertanto la nuova funzione:
y= (r-r/h^2*(x-h)^2  ) *(sin(p*180*x/h))^2       (3)
rappresenta una sinusoide i cui picchi seguono l’andamento della parabola.

Le curve (1), (2), (3) mantengono la medesima lunghezza d’onda.
Per avere una lunghezza d’onda variabile, partiamo dalla funzione (2) e immaginiamo di spostare orizzontalmente i punti della sinusoide, in modo che invece di seguire la direttrice retta, vadano a cadere sulla direttrice curva.
Per chiarire il procedimento, consideriamo questo tipo di movimento per i punti della retta:
y= r*x/h
in modo che vadano a cadere sulla curva:
y=r-r/h^2*(x-h)^2
In 2D la retta y= r*x/h per x appartenente a [0,h] si scrive:
!inizio script, inserire: m=risoluzione, h, r

for i=0 to m
x=h/m*i
y= r*x/h
put x,y
next i
poly2   m+1, 1, get (nsp)

Il punto di ascissa x, per finire sulla parabola, non dovrà più avere il valore originario, ma quel valore xx che sulla parabola corrisponde al punto di medesima ordinata y, calcolata originariamente sulla retta.
Occorre pertanto invertire la parabola:
y=r-r/h^2*(xx-h)^2          xx=h-h*sqr(1-y/r)   con y in [0,r]
Il nuovo script diventa:
for i=0 to m
yy=r/m*i
xx=h-h*sqr(1-yy/r)   
x=h/m*i
y= r*x/h
put xx,y
next i
poly2   m+1, 1, get (nsp)

Abbiamo ancora riottenuto la parabola, con la differenza che i nodi non sono equidistanti, ma si addensano verso O.
Applichiamo questo procedimento alla (2)  (sinusoide con aumento lineare):
for i=0 to m
yy=r/m*i
xx=h-h*sqr(1-yy/r)                     ! funzione inversa della parabola
x=h/m*i
y=r*x/h*(sin(p*180*x/h))^2     ! sinusoide con aumento lineare dell’ampiezza
put xx,y
next i
poly2 m+1, 1, get (nsp)

Abbiamo così ottenuto una sinusoide smorzata verso O, con riduzione della lunghezza d’onda.
Il rendering dello script mostra, però, l’inconveniente che nella parte destra si formano angolosità, essendo i nodi troppo distanti.  Per avvicinarli, senza cambiare la forma della curva, sia in yy che in x, che sono funzioni di i, sostituiamo i con sqr(m*i).
Per i=0 risulta ancora: sqr(m*i)=0; mentre per i=m si ha ancora:  sqr(m*i)=m
Infine la curva ricercata è:
for i=0 to m
yy=r/m*sqr(m*i)
xx=h-h*sqr(1-yy/r)
x=h/m*sqr(m*i)
y=r*x/h*(sin(p*180*x/h))^2
put xx,y
next i
poly2 m+1, 1, get (nsp)

A questo punto vogliamo utilizzare questa funzione come profilo per uno sferoide a cui è stata asportata la piramide del polo Sud, sostituendola con un poligono piano.
Questo sferoide, che ho denominato conoide, è stato ricavato dallo script della sfera primitiva:
!m=n° paralleli -1,  n=n° meridiani, r= raggio
BASE
Vert  0, 0, r  !Polo N
for j=1 to m-1
for i=0 to n-1
x=2*r/m *j
y=sqr(r^2-(x-r)^2)
Vert cos(360/n *i)*y,sin(360/n *i)*y, r-x
next i
next j
Vert  0, 0, -r  !Polo s

for j=0 to m-2
for i=1 to n-1
EDGE 1+n*j+i,1+n*j+i+1, -1, -1, s
next i
EDGE 1+n*j+n,1+n*j+1, -1, -1, s
next j

for j=0 to m-3
for i=1 to n
EDGE 1+i+n*j,1+n+i+n*j, -1, -1, s
next i
next j

for i=1 to n
EDGE 1+i,1, -1, -1, s
next i
for i=1 to n
EDGE 1+n*(m-2)+i,n*(m-1)+2, -1, -1, s
next i

for i=1 to n-1
PGON 3, 0, -1, i,n*(m-2)+n*(m-1)+1+i,-(n*(m-2)+n*(m-1)+i) !calotta nord
next i
PGON 3, 0, -1, n,n*(m-2)+n*(m-1)+1,-(n*(m-2)+n*(m-1)+n) !chiusura calotta nord

for i=1 to n-1
PGON 3, 0, -1, -(n*(m-2)+i),(n*(2*m-2)+i),-(n*(2*m-2)+1+i) !calotta sud
next i
PGON 3, 0, -1, -n*(m-1),(n*(2*m-1)),-(n*(m-2)+n*m+1) !chiusura calotta sud

for j=0 to m-3
for i=1 to n-1
PGON 4, 0, -1, -i-j*n,n*(m-1)+i+j*n ,n+i+j*n,-(n*(m-1)+1+i+j*n)
next i
PGON 4, 0, -1, -n-j*n,n*(m-1)+n+j*n ,2*n+j*n,-(n*(m-1)+1+j*n)
next j

Per ottenere la nuova primitiva si elimina il polo Sud:  vert  0, 0, -r.
Si porta poi il loop dei vertici con j che variava da 1 a m-1, a j variabile da 1 a m:  risultano pertanto aumentati di 1 i paralleli ( perché l’ultimo parallelo introdotto, corrispondente a m, va ora a sostituire il polo Sud, diventando la base).   Quindi nella parte dello script relativa a EDGE e  PGON occorre sostituire m con m+1.  Infine si eliminano i PGON a tre vertici, inserendo al loro posto:
for i=1 to n
put -(n*m+1-i)
next i
PGON nsp, 0, -1, get(nsp) !base di appoggio di n lati

La curva che vogliamo usare come profilo è:
y=r1*x/h*(sin(p*180*x/h))^2+r2*x/h
La parte r2*x/h serve per evitare che i minimi cadano sull’asse.

for j=0 to m
yy=r1/m*sqr(m*j)
x=h-h*sqr(1-yy/r1)
xx=h/m*sqr(m*j)
y=r1*xx/h*(sin(p*180*xx/h))^2+ r2*x/h
put x,y
next j
poly2 m+1, 1, get (nsp)

I parametri q e am si riferiscono al numero di picchi e alla loro ampiezza per la sinusoide che rende ondulati i paralleli.

!inizio script, parametri: m,n, p,h,r1,r2,q,am
r=h/2
base
Vert 0,0, r
for j=1 to m
for i=0 to n-1
yy=r1/m*sqr(m*j)
x=h-h*sqr(1-yy/r1)
xx=h/m*sqr(m*j)
y=r1*xx/h*(sin(p*180*xx/h))^2
u=1+am*(sin(360/n*i*q))
Vert cos(360/n*i)*y*u ,sin(360/n*i)*y*u, r-x
next i
next j

for j=0 to m-1 !m paralleli
for i=1 to n-1
EDGE 1+n*j+i,1+n*j+i+1, -1, -1, s
next i
EDGE 1+n*j+n,1+n*j+1, -1, -1, s
next j

for j=0 to m-2 !n meridiani
for i=1 to n
EDGE 1+i+n*j,1+n+i+n*j, -1, -1, s
next i
next j

for i=1 to n !2*n segmenti di meridiani al polo
EDGE 1+i,1, -1, -1, s
next i

for i=1 to n-1
PGON 3, 0, -1, i,n*(m-1)+n*m+1+i,-(n*(m-1)+n*m+i) !calotta nord
next i
PGON 3, 0, -1, n,n*(m-1)+n*m+1,-(n*(m-1)+n*m+n) !chiusura calotta nord

for i=1 to n
put -(n*m+1-i)
next i
PGON nsp, 0, -1, get(nsp) !bottom

for j=0 to m-2
for i=1 to n-1
PGON 4, 0, -1, -i-j*n,n*m+i+j*n ,n+i+j*n,-(n*m+1+i+j*n)
next i
PGON 4, 0, -1, -n-j*n,n*m+n+j*n ,2*n+j*n,-(n*m+1+j*n)
next j
body -1

La primitiva così definita è dunque ondulata, grazie alla funzione u=u(i), anche lungo i paralleli. Per costruire invece una semplice figura di rotazione si può utilizzare la forma predefinita:

REVOLVE   m, alfa, j1 + 2*j2 + 4*j3 + 8*j4 + 16*j5 + 32*j6 +64*j7,
x1, y1, s1, ... xm, ym, sm

L’asse di rotazione coincide con l’asse x.
m=      numero nodi
alfa=   angolo di rotazione rispetto xy (se=360 si ha completa rotazione)
si=       valore di stato dell’arco di latitudine uscente dal nodo (0=visibile)
j1=      base inferiore visibile
j2 =     base superiore visibile
j3=      superficie di taglio iniziale visibile (per alfa<180)
j4= superficie di taglio finale visibile (per alfa<180)
j5= spigoli visibili nella superficie di taglio iniziale
j6= spigoli visibili nella superficie di taglio finale
j7= superficie a spigoli netti (altrimenti morbida)

 
La superficie di rotazione, con l’aspetto di una pagoda, allora si scrive:

resol n

for j=0 to m
yy=r1/m*sqr(m*j)
x=h-h*sqr(1-yy/r1)
xx=h/m*sqr(m*j)
y=r1*xx/h*(sin(p*180*xx/h))^2+ r2*x/h
put x,y,s
next j

REVOLVE   m+1, 360, 3+64*j7,
get  ( nsp )

Risulta quindi evidente che il primo script, sebbene più complesso, permette maggiori interventi, tra cui anche la possibilità di inserire materiali diversi.

Gli oggetti di riferimento di questo esercizio sono:
sinus2 smorzato.gsm, con la parte 2D
sinus2 smorzato_z,u.gsm, oggetto 3D costruito con il conoide
sinus2 smorzato_z.gsm, oggetto 3D costruito con revolve