vers l'index général de l'aide

matrix

Rien à voir avec le célèbre navet new-age, rassurez-vous...

objectif

Appliquer des transformations spatiales de type rotate, scale, translate, aux objets et éléments de textures, à l'aide d'une matrice de valeurs, avec une petite possibilité en plus, le biaisage ("shearing").

explication

Lorsque POV-Ray interprète une série de transformations successives, il stocke la transformation dans une matrice de 4 x 4 valeurs, décrivant le déplacement des points dans l'espace. Le mot clé matrix vous permet d'accéder directement à cette matrice. Nous allons voir dans quels cas il est utile d'y recourir.

syntaxe

matrix <A1, A2, A3, 
        B1, B2, B3, 
        C1, C2, C3, 
        D1, D2, D3>

Plus haut, nous avons parlé de 4 x 4 valeurs, alors que la syntaxe n'en comporte que 3 x 4 ! Il y a en fait une quatrième colonne, implicite, dont les valeurs sont constantes. Le tableau suivant est donc la représentation "interne" de la matrice :

La transformation d'un point se fait suivant le processus suivant. Pour tout point :

P = <px,py,pz>

...le point résultant après transformation sera :

Q = <qx,qy,qz>

...déterminé par les formules suivantes :

qx = A1 * px + B1 * py + C1 * pz + D1
qy = A2 * px + B2 * py + C2 * pz + D2
qz = A3 * px + B3 * py + C3 * pz + D3

transformations "classiques"

Voici, à titre d'exemple, l'équivalent matriciel des transformations courantes de POV-Ray.

scale

scale <Sx,Sy,Sz> 
 donne :
matrix <Sx,  0,  0,
         0, Sy,  0,
         0,  0, Sz,
         0,  0,  0 >

translate

translate <Tx,Ty,Tz> 
 donne :
matrix <1,  0,  0,
        0,  1,  0,
        0,  0,  1,
       Tx, Ty, Tz>

Notez qu'il est relativement facile de combiner les opérations de scale et translate dans une même matrice, puisque leurs valeurs de contrôle sont distinctes.

rotate

Là, ça se corse, car il faut effectuer des transformations trigonométriques préalables !

rotate x*Angle
 donne :
#declare As = sin (radians(Angle));
#declare Ac = cos (radians(Angle));
  matrix <  1,  0,  0,
            0,  Ac, As,
            0, -As, Ac,
            0,  0,  0 >

rotate y*Angle
 donne :
#declare As = sin (radians(Angle));
#declare Ac = cos (radians(Angle));

   matrix <  Ac,  0, -As,
             0,  1,  0,
             As, 0,  Ac,
             0,  0,  0 >

rotate z*Angle
 donne :
#declare As = sin (radians(Angle));
#declare Ac = cos (radians(Angle));

   matrix <  Ac,  As,  0,
            -As,  Ac,  0,
             0,  0,  1,
             0,  0,  0 >

Ici, la combinaison devient beaucoup plus difficile, et implique l'usage des opérations sur les matrices, que nous n'aborderons pas ici ! Allez voir vos vieux livres de maths, ça devrait s'y trouver.

biaisage

La seule transformation que seule la matrice permet, c'est de biaiser les objets, c'est à dire leur appliquer une torsion suivant les axes. La torsion est exprimée en rapport du déplacement sur deux axes, pour chaque unité sur le troisième axe.

torsion sur X et Y
   matrix < 1,  0,  0,
            0,  1,  0,
           Gx, Gy,  1,
            0,  0,  0 >

Par exemple, un déplacement de 0.2 unités le long de X et de 0.5 unités le long de Y, pour chaque unité en Z :

   matrix < 1,  0,  0,
            0,  1,  0,
           .2, .5,  1,
            0,  0,  0 >

torsion sur X et Z

   matrix <  1,  0,  0,
            Gx,  1, Gz,
             0,  0,  1,
             0,  0,  0 >

torsion sur Y et Z

   matrix <  1, Gy, Gz,
             0,  1,  0,
             0,  0,  1,
             0,  0,  0 >

remarques

Puisque, en interne, POV-Ray finit toujours par traduire toutes les transformations successives en une matrice unique, il n'y a aucun intérêt technique à les employer pour remplacer scale, rotate et translate. Il n'y a que deux cas de figure ou leur utilisation est nécessaire/souhaitable :

- pour effectuer un "biaisage".

- lorsque, grâce à votre livre de maths, vous êtes en mesure de produire, à l'aide d'une matrice, une écriture plus élégante qu'une série équivalente de transformations classiques.

Rédacteur: Fabien Mosen