...

Selezione di formule e algoritmi per designer.

home ← decode

Lista Formule

Formule trovate: 20

  • 001 Rose di Grandi
  • 002 Moto Parabolico
  • 003 Matrice di esagoni
  • 004 Archi e Lati
  • 005 Cerchio per tre punti
  • 006 Intersezione di cerchi
  • 007 Dot Product
  • 008 Pendolo
  • 009 Bilancia
  • 010 Proiezione
  • 011 Punto dentro un poligono
  • 012 Perpendicolare
  • 013 Intersezione di segmenti
  • 014 Interpolazione di Bezier
  • 015 Interpolazione Catmull-Rom
  • 016 Interpolazione Hermite
  • 017 Movimento Browniano
  • 018 Pattern di Truchet
  • 019 Rotolamento
  • 020 Forze
  • Rose di Grandi

    Formula per il disegno di curve

    • 001

    • /* ----------------------------------------------  
      FORMULA COORDINATE POLARI: R=SIN(PETALI*ANGOLO) 
      -----------------------------------------------*/ 
      
      // ---------------------------------------------- Costanti  
      var RADIANTI = Math.PI/180;
      var GRADI = 180/Math.PI;
      var PI2 = Math.PI*2;
      var CENTROX = 350;
      var CENTROY = 200;
      
      // ---------------------------------------------- VARIABILI 
      var petali = 3;
      var raggio = 150;
      
      // ---------------------------------------------- FUNZIONI  
      function RosediGrandi(petali, raggio) {
          var punti = 40*petali;
          var t = r=x=y=0;
          disegno.clear();
          disegno.lineStyle(8,0x222222,100);
          for (var i = 0; i<=punti; i++) {
              t = (i/punti)*PI2;
              r = raggio*Math.sin(petali*t);
              x = CENTROX+r*Math.cos(t);
              y = CENTROY+r*Math.sin(t);
      
              //disegna la curva 
              (i) ? disegno.lineTo(x, y) : disegno.moveTo(x, y);
          } 
      } 
      
  • Moto Parabolico

    formule per la traiettoria

    • 002

    • 
      /*----------------------------------------------
      
      FORMULE: 
      
      distanza=arrivo-origine.x 
      α = (0-90)*RADIANTI 
      v0=SQRT((distanza*gravita)/(2*SIN(α)*COS(α))); 
      
      vx=spinta*COS(α),  
      vy=spinta*SIN(α)); 
      
      tempototalevolo = (vy/gravita)*2; 
      
      
      // calcolo punto nel momento t 
      x = origine.x+vx*t; 
      y = origine.y-vy*t+.5*gravita*(t*t); 
      
      ----------------------------------------------*/ 
      
      
      
      
      import flash.geom.Point;
      
      // ---------------------------------------------- COSTANTI  
      var RADIANTI = Math.PI/180;
      var GRADI = 180/Math.PI;
      var PI2 = Math.PI*2;
      var CENTROX = 350;
      var CENTROY = 200;
      
      // ---------------------------------------------- VARIABILI  
      var gravita = 9.81;
      var inc = .1;
      var origine:Point = new Point(missile_mc._x, missile_mc._y);
      var arrivo:Number = base_mc._x;
      var velocita:Point = new Point(0, 0);
      var tempototale = 0;
      var tempo = 0;
      var verso=1
      var involo = false;
      // ---------------------------------------------- FUNZIONI  
      // genera un numero casuale tra min e max
      function Rand(min, max) {
          if (min>max) {
              return 0;
          } 
          return min+Math.random()*(max-min);
      } 
      
      // calcola la parbola in base alla velocità e il tempo
      function CalcolaTraiettoria(velx, vely, t):Point {
          var p:Point = new Point(0, 0);
          p.x = velx*t;
          p.y = -vely*t+.5*gravita*(t*t);
          return p;
      } 
      
      function Loop() {
          tempo += inc;
          if (tempo<=tempototale) {
              var vettore = CalcolaTraiettoria(velocita.x, velocita.y, tempo);
              missile_mc._x = origine.x+vettore.x;
              missile_mc._y = origine.y+vettore.y;
          }  
      } 
      
      function Init() {
          tempo = 0;
      
          // parametri per calcolo della traiettoria e del tempo di volo
          //------------------------------------------------------------------------------- 
          // distanza target 
          var distanza=(arrivo>origine.x)?arrivo-origine.x:origine.x-arrivo 
          // corregge direzione 
          verso=(arrivo>origine.x)?1:-1 
           
          // calcola l'angolo iniziale
          var angolo = (90-Rand(15, 45))*RADIANTI;
          // spinta necessari per raggiungere il target
          var spinta:Number = Math.sqrt((distanza*gravita)/(2*Math.sin(angolo)*Math.cos(angolo)));
           
          // vettore di volo 
          velocita = new Point(spinta*Math.cos(angolo)*verso, spinta*Math.sin(angolo));
      
          // tempo totale di volo 
          tempototale = (velocita.y/gravita)*2;
      
          //------------------------------------------------------------------------------- 
      }
  • Matrice di esagoni

    Algoritmo per il posizionamento

    • 003

    • /*----------------------------------------------
      Algoritmo: 
      
      In un esagono tutte le misure  dipendono dal lato,  
      quindi settando il lato è possibile calcolare  tutti i valori mancanti.  
      
      L'altezza         h= sin( 30°) * lato 
      La distanza     r = cos( 30°) * lato 
      L'altezza del rettangolo che circonda l'esagono     b = lato + 2 * h 
      La larghezza del rettangolo che circonda l'esagono  a = 2 * r 
      
      Usando il l'istruzione modulo  (%) è possibile calcolare 
      le righe pari e dispari in modo da allineare la matrice. 
      
      La posizione di ogni esagono si ricava: 
      
        
      X = j*2*R+R*(i%2) 
      Y = i*(h+lato); 
      
      con  
      0 ≥ i ≤ numero di esagoni  per le righe  
      0 ≥ j ≤ numero di esagoni  per le colonne 
      
      ----------------------------------------------*/ 
      
      
      // ---------------------------------------------- Costanti  
      var RADIANTI = Math.PI/180;
      var GRADI = 180/Math.PI;
      var PI2 = Math.PI*2;
      
      // ---------------------------------------------- VARIABILI  
      
      var cellex = 10;
      var celley = 10;
      var latoesagono = 21;
      var h = latoesagono*Math.sin(30*RADIANTI);
      var r= latoesagono*Math.cos(30*RADIANTI);
      
      
      // crea la matrice di esagoni 
      var id = 1;
      var esagono_mc:MovieClip;
      for (var i = 0; i<celley; i++) {
          for (var j = 0; j<cellex; j++) {
              esagono_mc = disegno.attachMovie("hex", "c"+id, id++);
              // posiziona 
              esagono_mc._x = 50+j*2*r+r*(i%2);
              esagono_mc._y = 40+i*(h+latoesagono);
          } 
            
      }
  • Archi e Lati

    archi di circonferenza e i lati di poligoni regolari

    • 004

    • // ---------------------------------------------- COSTANTI  
      var RADIANTI = Math.PI/180;
      var GRADI = 180/Math.PI;
      var PI2 = Math.PI*2;
      var centro=new Point(350,200)
      // ---------------------------------------------- VARIABILI  
      var npetali = 10;
      var raggio = 100;
      // ---------------------------------------------- FUNZIONI 
      
      function Arcodicerchio() {
           
          //angolo 
          var a = PI2/npetali;
      
          // lunghezza arco 2rSin(Ï€/n)
          var S = 2*raggio*Math.sin(Math.PI/npetali);
      
          for (var i = 0; i<npetali; i++) {
               
              var cerchio = _root.attachMovie("cerchio", "c"+i, i);
              var posizione = Point.polar(raggio, a*i).add(centro);
      cerchio._x = posizione.x;
      cerchio._y = posizione.y;
              cerchio._width = cerchio._height=S;
               
          } 
           
      }
  • Cerchio per tre punti

    calcolo del raggio e del centro del cerchio

    • 005

    • 
      // ---------------------------------------------- FUNZIONI 
      // calcola il quadrato del numero
      function sqr(n) {
          return (n*n);
      } 
      
      // scambia i punti 
      function swap(p1:Point, p2:Point) {
          var tmp = new Point();
          tmp = p1;
          p1 = p2;
          p2 = temp;
      } 
      
      // trova il centro del cerchio definito da tre punti
      function TrovaCentro(p1:Point, p2:Point, p3:Point) {
          var xc, yc, ma, mb:Number;
          var test = true;
           
          // verifica la pendenza delle linee
          if ((p1.x == p2.x) or (p1.y == p2.y)) {
              swap(p2,p3);
          } 
          if (p2.x == p3.x) {
              swap(p1,p2);
          } 
          if (p1.x<>p2.x) {
              ma = (p2.y-p1.y)/(p2.x-p1.x);
          } else {
              test = false;
          } 
          if (p2.x<>p3.x) {
              mb = (p3.y-p2.y)/(p3.x-p2.x);
          } else {
              test = false;
          } 
          if ((ma == 0) and (mb == 0)) {
              test = false;
          } 
          // calcola le coordinate per il centro   
          if (test) {
              xc = (ma*mb*(p1.y-p3.y)+mb*(p1.x+p2.x)-ma*(p2.x+p3.x))/(2*(mb-ma));
      
              if (ma<>0) {
                  yc = -(xc-(p1.x+p2.x)/2)/ma+(p1.y+p2.y)/2;
              } else {
                  yc = -(xc-(p2.x+p3.x)/2)/mb+(p2.y+p3.y)/2;
              } 
              var centro = new Point(xc, yc);
              return centro;
          } 
          return false;
      } 
      
      // trova il raggio del cerchio definito da tre punti
      function TrovaRaggio(p1:Point, p2:Point, p3:Point) {
          var s, a, b, c, r:Number;
          a = Math.sqrt(sqr(p1.x-p2.x)+sqr(p1.y-p2.y));
          b = Math.sqrt(sqr(p2.x-p3.x)+sqr(p2.y-p3.y));
          c = Math.sqrt(sqr(p3.x-p1.x)+sqr(p3.y-p1.y));
          s = (a+b+c)/2;
          r = (a*b*c)/(4*Math.sqrt(s*(s-a)*(s-b)*(s-c)));
          return r;
      } 
      
      function DisegnaCerchio() {
          var p1 = new Point(c1._x, c1._y);
          var p2 = new Point(c2._x, c2._y);
          var p3 = new Point(c3._x, c3._y);
      
          var raggio:Number = TrovaRaggio(p1, p2, p3);
          var centro:Point      = TrovaCentro(p1, p2, p3);
      
          cerchio._x = centro.x;
          cerchio._y = centro.y;
          cerchio._width = cerchio._height=raggio*2;
          cerchio._alpha = 100-(raggio*90/400);
      }
  • Intersezione di cerchi

    calcolo dei punti

    • 006

    • /* 
             Intersezione di cerchi 
      */ 
      
      // ---------------------------------------------- VARIABILI  
      var r1 = 100;
      var r2 = 140;
      // ---------------------------------------------- FUNZIONI 
      
      function DisegnaCerchio(x, y, r, c, a) {
          disegno.beginFill(c,a);
          disegno.moveTo(x+r,y);
          disegno.curveTo(r+x,0.4142*r+y,0.7071*r+x,0.7071*r+y);
          disegno.curveTo(0.4142*r+x,r+y,x,r+y);
          disegno.curveTo(-0.4142*r+x,r+y,-0.7071*r+x,0.7071*r+y);
          disegno.curveTo(-r+x,0.4142*r+y,-r+x,y);
          disegno.curveTo(-r+x,-0.4142*r+y,-0.7071*r+x,-0.7071*r+y);
          // 
          disegno.curveTo(-0.4142*r+x,-r+y,x,-r+y);
          disegno.curveTo(0.4142*r+x,-r+y,0.7071*r+x,-0.7071*r+y);
          disegno.curveTo(r+x,-0.4142*r+y,r+x,y);
          disegno.endFill();
      } 
      function DisegnaLinea(x1, y1, x2, y2, c, a) {
          disegno.lineStyle(0,c,a);
          disegno.moveTo(x1,y1);
          disegno.lineTo(x2,y2);
      } 
      
      function Calcola() {
          x1 = n1._x;
          y1 = n1._y;
          x2 = n2._x;
          y2 = n2._y;
      
          // mostra i cerchi 
          disegno.clear();
          DisegnaCerchio(x1,y1,r1,0xAA8899,10);
          DisegnaCerchio(x2,y2,r2,0x998899,20);
          //-------------------------------------- 
          // calcola la distanza  
          var dx = x2-x1;
          var dy = y2-y1;
          var distanza = Math.sqrt(dx*dx+dy*dy);
          if ((distanza>r1-r2) && (distanza<r1+r2)) {
              // normalizza 
              var dxnorm = dx/distanza;
              var dynorm = dy/distanza;
      
              // distanza dal centro 1 alla linea di intersezione
              var intersezione = (distanza*distanza+r1*r1-r2*r2)/(2*distanza);
              var sq = Math.sqrt(r1*r1-intersezione*intersezione);
      
              // trova i due punti di intersezione
              var xs1 = x1+dx*intersezione/distanza+dynorm*sq;
              var ys1 = y1+dy*intersezione/distanza-dxnorm*sq;
              var xs2 = x1+((dx*intersezione)/distanza)-dynorm*sq;
              var ys2 = y1+((dy*intersezione)/distanza)+dxnorm*sq;
      
              // mostra i punti di intersezione 
              DisegnaCerchio(xs1,ys1,5,0x000000,100);
              DisegnaCerchio(xs2,ys2,5,0x000000,100);
              DisegnaLinea(xs1,ys1,xs2,ys2,0,10);
              DisegnaLinea(x1,y1,x2,y2,0,10);
          } 
      } 
      
      // ---------------------------------------------- INIT  
      Calcola();
  • Dot Product

    calcolo dell'angolo tra due vettori

    • 007

    • /* 
      dot product  
      calcolo dell'angolo tra due vettori 
      */ 
      
      // dot product  
      DotProduct = function (v1, v2) {
          return (v1.x*v2.x)+(v1.y*v2.y);
      };
      
      esempio:
      var p1=new Point(100,200);
      var p2=new Point(200,250);
      var p3=new Point(300,350);
      var vett1=new Point(p1.x-p2.x,p1.y-p2.y);
      var vett2=new Point(p1.x-p3.x,p1.y-p3.y)
      var dot=DotProduct(vett1,vett2);
  • Pendolo

    calcolo dei parametri per l'oscillazione smorzata

    • 008

    • /* 
      PENDOLO 
      Calcolo dei valori per l'oscillazione 
      */ 
      
      import flash.geom.Point;
      
      // ---------------------------------------------- COSTANTI  
      var PI2 = Math.PI*2;
      var _PI = Math.PI/2;
      // ---------------------------------------------- VARIABILI  
      var tempo = 0;
      var tempoinc = .5;
      var Gravita = 9.81;
      var Smorzamento = .999;
      var LunghezzaFilo = 140;
      var Periodo = Math.PI*Math.sqrt(LunghezzaFilo/Gravita);
      var Angolo = Math.atan2(massa._y-centro._y, massa._x-centro._x)-Math.PI/4;
      var cliccato = false;
      // ---------------------------------------------- FUNZIONI 
      massa.onPress = function() {
          this.startDrag(false, 50, centro._y, 500, 260);
          cliccato = true;
          Periodo = 0;
          tempo = 0;
      };
      massa.onRelease = massa.onReleaseOutside=function () {
          var p1 = new Point(massa._x, massa._y);
          var p2 = new Point(centro._x, centro._y);
           
          // calcola la lunghezza del filo
          var dx = p1.x-p2.x;
          var dy = p1.y-p2.y;
          LunghezzaFilo = Math.sqrt(dx*dx+dy*dy);
           
          // Controlla la lunghezza del filo
          LunghezzaFilo = Math.min(Math.max(LunghezzaFilo, 1), 200);
           
          // Calcola il periodo e angolo
          Periodo = Math.PI*Math.sqrt(LunghezzaFilo/Gravita);
          Angolo     = Math.atan2(p1.y-p2.y, p1.x-p2.x)-_PI;
          cliccato = false;
          stopDrag();
      };
      // ---------------------------------------------- INIT  
      this.onEnterFrame = function() {
          if (!cliccato) {
              if (Periodo != 0) {
                  var a = Angolo*Math.cos(PI2*tempo/Periodo)+_PI;
                  // coordinate polari
                  var xp = centro._x+LunghezzaFilo*Math.cos(a);
                  var yp = centro._y+LunghezzaFilo*Math.sin(a);
                  // muove gli elementi
                  massa._x = xp;
                  massa._y = yp;
                  ombramassa._alpha = 20-Math.abs(massa._y-250)*20/200;
                  ombramassa._x = massa._x;
                  //applica uno smorzamento e incrementa il tempo
                  Angolo *= Smorzamento;
                  tempo += tempoinc;
              } 
          } else {
              ombramassa._x = massa._x;
              ombramassa._alpha = 20-Math.abs(massa._y-250)*20/200;
          } 
          disegno.clear();
          disegno.lineStyle(0, 0x000000, 20);
          disegno.moveTo(centro._x, centro._y);
          disegno.lineTo(massa._x, massa._y);
      };
      
  • Bilancia

    Formule per il calcolo dell'equilibrio

    • 009

    • /* 
          BILANCIA 
          Formule per il calcolo dell'equilibrio 
      */ 
      
      var RADIANTI= Math.PI/180
      var lunghezzaAsta = 300;
      var posL = -100;
      var posR = 100;
      var braccioL=100
      var braccioR=100
      var braccioL2 = braccioL*braccioL;
      var braccioR2 = braccioR*braccioR;
      var gravita = 9.81;
      var MassaL = 150;
      var MassaR = 150;
      
      function  Bilancia () {
          // calcola il momento e inerzia
          var tau1 = MassaL*gravita*braccioL;
          var tau2 = MassaR*gravita*braccioR;
          var inerzia = (MassaL*braccioL2+MassaR*braccioR2)*.01;
          var sommatau = (tau2-tau1)+0.5*braccioR2*gravita-0.5*braccioL2*gravita;
           
          // calcola e limita la rotazione
          rotazione += sommatau/inerzia;
          rotazione = Math.min(Math.max(rotazione, -45), 45);
           
          // riposiziona i pesi in base alla rotazione
          var a = rotazione*RADIANTI;
          clipML._x = -braccioL*Math.cos(a);
          clipML._y = -braccioL*Math.sin(a);
          clipMR._x = braccioR*Math.cos(a);
          clipMR._y = braccioR*Math.sin(a);
      
          // ruota i bracci 
          clipAsta._rotation = rotazione;
      }
  • Proiezione

    Algoritmo per la proiezione di punti

    • 010

    • 
      /* 
          PROIEZIONE DI PUNTI 
          Algoritmo per la proiezione di punti 
      */ 
      
      var  terra =400
      // ritorna il punto proiettato tra il vertice p e la fonte di luce verso terra
      function Proietta(p, luce) {
          var s = new Object();
          var k = -p.y/(p.y-luce.y);
          s.x = Math.round(p.x+(p.x-luce.x)*k);
          s.y = Math.round(terra+p.y+(p.y-luce.y)*k);
          return s;
      } 
      
      esempio:
      
      var sole=new Point(300,100)
      var vertice=new Point(200,300)
      var proiettato=Proietta(vertice, sole) 
  • Punto dentro un poligono

    algoritmo per testare se un punto è dento un poligono

    • 011

    • 
      /* 
          Punto dentro un poligono 
          test di contenimento 
      */ 
      
      function PuntoInPoligono(forma:Array, p:Point) {
          var c = false;
          var n = forma.length;
          var pa, pb;
          for (var i = 0; i<n; i++) {
              pa = forma[i];
              pb = forma[(i+1)%n];
              if ((((pa.y<=p.y) && (p.y<pb.y)) || ((pb.y<=p.y) && (p.y<pa.y))) && (p.x<(pb.x-pa.x)*(p.y-pa.y)/(pb.y-pa.y)+pa.x)) {
                  c = !c;
              } 
          } 
          if (c) {
              return true;
          } else {
              return false;
          } 
      } 
      
      // poligono e punto per la verifica 
      poligono=new Array(p1,p2,p3,p4,p5)
      punto=new Point(100,200)
      
      test = PointInPolygon(poligono, punto);
      
  • Perpendicolare

    calcolare la perpendicolare ad un segmento

    • 012

    • /* 
          PERPENDICOLARE 
          calcolare la perpendicolare  ad un segmento 
      */ 
      
      
      PerpendicolarePuntoSegmento = function (p, p1, p2) {
          var t, dx, dy, np;
          dx = p2.x-p1.x;
          dy = p2.y-p1.y;
          d = Math.sqrt(dx*dx+dy*dy);
          t = ((p.x-p1.x)*dx+(p.y-p1.y)*dy)/d;
          t = (t<0) ? 0 : t;
          t = (t>d) ? d : t;
          np = new xy(p1.x+t*dx/d, p1.y+t*dy/d);
          return np;
      };
      
      //esempio: 
      var p=new Point(150,150)
      var s1=new Point(100,200)
      var s2=new Point(300,400)
      var perp= PerpendicolarePuntoSegmento(p,s1,s2)
  • Intersezione di segmenti

    calcolo del punto di intersezione

    • 013

    • 
      /* 
          Intersezione di 2 segmenti 
          calcolo del punto di intersezione 
      */ 
      function IntersezioneSegmenti (p1, p2, p3, p4) {
          var v = ((p4.x-p3.x)*(p1.y-p3.y)-(p4.y-p3.y)*(p1.x-p3.x))/((p4.y-p3.y)*(p2.x-p1.x)-(p4.x-p3.x)*(p2.y-p1.y));
          if ((v>0) and (v<1)) {
              return v;
          } else {
              return null;
          } 
      };
      
      // calcola  il punto  per i segmenti definiti da p1,p2,p3,p4
      var t = IntersezioneSegmenti(p1, p2, p3, p4);
      if (t) {
          np._x = p1.x*(1-t)+p2.x*t;
          np._y = p1.y*(1-t)+p2.y*t;
      } 
      
  • Interpolazione di Bezier

    metodo deCasteljau

    • 014

    • /* 
          Interpolazione Bezier  
          Metodo deCasteljau 
      */ 
      
      // Metodo per trovare un punto sulla curva
      // in base al parametro t [0-1] 
      function BezierdeCasteljau(punti, t) {
          curr = new Array();
          next = punti;
          while (next.length>1) {
          curr = next;
          next = new Array();
          for (var i = 0; i<curr.length-1; i++) {
              p = new xy();
              p.x = (1-t)*curr[i].x+t*curr[i+1].x;
              p.y = (1-t)*curr[i].y+t*curr[i+1].y;
              next[i] = p;
          } 
          } 
          return next[0];
      } 
      
      // punti da interpolare 
      punti =[p1,p2,p3,p4,p5]
      p=BezierdeCasteljau(punti,.5)
  • Interpolazione Catmull-Rom

    calcolo di punti su curve spline

    • 015

    • /* 
          Interpolazione Catmull-Rom 
          disegno di una lista di punti su una curva spline 
      */ 
      
      //Nota: In una sequenza di punti il primo e l'ultimo punto devono essere doppi
      function CatmullRom(p1, p2, p3, p4, t) {
          var t2 = t*t;
          var t3 = t2*t;
          var p = new Object();
          p.x = (((-p1.x+3*p2.x-3*p3.x+p4.x)*t3)+((2*p1.x-5*p2.x+4*p3.x-p4.x)*t2)+((-p1.x+p3.x)*t)+(2*p2.x))*.5;
          p.y = (((-p1.y+3*p2.y-3*p3.y+p4.y)*t3)+((2*p1.y-5*p2.y+4*p3.y-p4.y)*t2)+((-p1.y+p3.y)*t)+(2*p2.y))*.5;
          return p;
      } 
      
      //---------------------------------------------------- 
      // array di punti 
      Curva=new Array(p0,p1,p2,p3,p4,p5,p6,p7);
      
      for (var i = 1; i<Curva.length-2; i++) {
          p0 = Curva[i-1];
          p1 = Curva[i];
          p2 = Curva[i+1];
          p3 = Curva[i+2];
          disegno.moveTo(p1.x, p1.y);
          steps=10
          for (var j = 0; j<=steps; j++) {
              t = j/steps;
              p = CatmullRom(p0, p1, p2, p3, t);
              lineTo(p.x, p.y);
          } 
          } 
      }
  • Interpolazione Hermite

    punti su curve spline con tensione variabile

    • 016

    • /* 
          Interpolazione Hermite 
          disegno di punti su curve spline con tensione variabile 
      */ 
      
      tensione=0
      steps=10
      
      
      //Tensione: 1 alta, 0 normale, -1 bassa 
      function Hermite (n0, n1, n2, n3, t, tensione) {
          var m0, m1, mu2, mu3;
          var a0, a1, a2, a3;
          var t2,t3,te
          t2 = t*t;
          t3 = t2*t;
          te = 1-tensione;
          m0 = (n1-n0)*te*.5;
          m0 = m0+(n2-n1)*te*.5;
          m1 = (n2-n1)*te*.5;
          m1 = m1+(n3-n2)*te*.5;
          //  
          a0 = 2*t3-3*t2+1;
          a1 = t3-2*t2+t;
          a2 = t3-t2;
          a3 = -2*t3+3*t2;
          return (a0*n1+a1*m0+a2*m1+a3*n2);
      };
      
      //Nota: In una sequenza di punti il primo e l'ultimo  punto devono essere doppi
      // array di punti 
      Curva=new Array(p0,p0,p1,p2,p3,p4,p5,p6,p7,p7);
      
      for (var i = 1; i<Curva.length-2; i++) {
          p0 = Curva[i-1];
          p1 = Curva[i];
          p2 = Curva[i+1];
          p3 = Curva[i+2];
          disegno.moveTo(p1.x, p1.y);
          for (var j = 0; j<=steps; j++) {
              t = j/steps;
              p = new Point();
              p.x = Hermite(p0.x, p1.x, p2.x, p3.x, t, tensione);
              p.y = Hermite(p0.y, p1.y, p2.y, p3.y, t, tensione);
              lineTo(p.x, p.y);
          } 
      } 
      
      
  • Movimento Browniano

    calcolo del movimento casuale di particelle

    • 017

    • /* 
          Movimento Browniano 
          movimaneto casuale di particelle 
      */ 
      
      var GRADI=180/Math.PI;
      var pos = new Point(300, 300);
      var range = Math.PI/20;
      var angolo = Math.random()*(Math.PI*2);
      var passo = 2+Math.random()*3;
      
      // calcola il movimento browniano
      function Sposta () {
          angolo += range-Math.random()*(range*2);
          // vettore di movimento 
          pos.x += passo*Math.cos(angolo);
          pos.y += passo*Math.sin(angolo);
          // limita spostamento 
          if (pos.x>500) {
          pos.x = 500;
          angolo += range;
          } 
          if (pos.x<50) {
          pos.x = 50;
          angolo += range;
          } 
          if (pos.y>400) {
          pos.y = 400;
          angolo += range;
          } 
          if (pos.y<50) {
          pos.y = 50;
          angolo += range;
          } 
          // sposta e ruota 
          this._x = pos.x;
          this._y = pos.y;
          this._rotation = angolo*GRADI;
      };
      
      this.onEnterFrame=Sposta
  • Pattern di Truchet

    disegno della matrice

    • 018

    • /* 
          Pattern di Truchet 
          disegno della matrice 
      */ 
      
      // ---------------------------------------------- VARIABILI  
      var colonne = 10
      var righe = 10
      var lar = 40;
      var old = 0;
      var p0 = .5;
      var p1 = .5;
      var lista = new Array();
      var id = 1;
      // ---------------------------------------------- FUNZIONI 
      function Truchet() {
          var num = 0;
          var id = 0;
          for (var i = 0; i<righe; i++) {
              for (var j = 0; j<colonne; j++) {
                  caso = Math.random();
                  if (old == 0) {
                      num = (caso<p0) ? 0 : 1;
                  } 
                  if (old == 1) {
                      num = (caso<p1) ? 1 : 0;
                  } 
                  old = num;
                   
                  var clip = lista[id];
                  clip._rotation = (num) ? 90 : 0;
                  id++;
              } 
          } 
      } 
      
      
      // ---------------------------------------------- INIT  
      for (var i = 0; i<righe; i++) {
          for (var j = 0; j<colonne; j++) {
              var clip = _root.disegno.attachMovie("box", "b"+id, id);
              clip._x = Math.round(lar*j)+20;
              clip._y = Math.round(lar*i)+20;
              clip._width = clip._height=lar;
              lista.push(clip);
              id++;
          } 
      } 
      
      Truchet();
  • Rotolamento

    calcolo della rotazione di oggetti

    • 019

    • /* 
          Rotolamento 
          calcolo della rotazione di oggetti 
      
      
          Formule: 
           
          rotazione=spostamento*(360/circonferenza) 
          numerodigiri=spostamento/circonferenza 
      
      
      */ 
      
      
      
      import flash.geom.Point;
      
      // ---------------------------------------------- COSTANTI  
      var PI2 = Math.PI*2;
      // ---------------------------------------------- VARIABILI  
      var cliccato = false;
      var posizione = 0;
      var rotazione = 0;
      var dx = 0;
      var precedentemouse:Point = new Point(0,0);
      var raggio = ruota_mc._width/2;
      var circonferenza = raggio*PI2;
      
      // ---------------------------------------------- FUNZIONI 
      function Rotazione(spostamento,) {
          var rotolamento = spostamento*(360/circonferenza);
          ruota_mc._x = posizione +spostamento;
          ruota_mc._rotation = rotazione + rotolamento;
      } 
      
      
      _root.onMouseMove = function() {
          if (cliccato) {
              var dx = _xmouse-precedentemouse.x;
              Rotazione(dx);
          } 
      };
      
      _root.onMouseDown = function() {
          precedentemouse = new Point(_xmouse,_ymouse);
          posizione = ruota_mc._x;
          rotazione = ruota_mc._rotation;
          cliccato = true;
      };
      _root.onMouseUp = function() {
          cliccato = false;
      };
  • Forze

    calcolo delle forze applicate agli oggetti

    • 020

    • // ---------------------------------------------- COSTANTI  
      var GRAVITA = 9.81;
      // ---------------------------------------------- VARIABILI  
      var massa = 10;
      var calore = 0;
      var accy = 0;
      var vely = 0;
      var frizione = .005;
      // ---------------------------------------------- INIT  
      onEnterFrame = function() {
      
          // somma delle forze 
          var spinta = GRAVITA+calore;
      
          // resistenza al movimento 
          spinta *= frizione;
      
          //2°; legge di Newton per accelerazione
          accy = spinta/massa;
      
          // somma accellerazione a velocità
          vely = Math.max(vely+accy, -3);
      
          // somma la velocità alla posizione
          pallone._y = pallone._y+vely;
      
          // raffreddamento 
          calore *= .5;
      
      };
      
      
      onMouseDown=function(){
          calore+=5
      }
cliccare sulle immagini per attivare le animazioni

DeCode Nostatic 2009