SMatrix4x4

java.lang.Object
- sim.math.SMatrix4x4

```
public class SMatrix4x4
extends java.lang.Object
```
La classe SMatrix4x4 représentant une matrice de '4' lignes et '4' colonnes. Les composantes de la matrice respectent la notation suivante :
M[i][j] =

| m00 m01 m02 m03 |

| m10 m11 m12 m13 |

| m20 m21 m22 m23 |

| m30 m31 m32 m33 |
Puisque l'implémentation de cette matrice se fera à l'aide d'un tableau à une dimension, on retrouve l'indexation suivante :
M[i][j] =

| 0 1 2 3 |

| 4 5 6 7 |

| 8 9 10 11 |

| 12 13 14 15 |

Since:

2015-05-27

Version:

2016-03-15

Author:

Simon Vézina

Constructor Summary

Constructors
Constructor and Description
`SMatrix4x4()` Constructeur de la matrice nulle (tous les éléments M[i][j] seront nuls.)
`SMatrix4x4(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33)` Constructeur d'une matrice 4x4 avec paramètres en coordonnée M[i][j] tel que i correspond à la ligne et j correspond à la colonne.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`equals(java.lang.Object obj)`
`int`	`hashCode()`
`static SMatrix4x4`	`identity()` Méthode pour obtenir la matrice identité I.
`SMatrix4x4`	`multiply(SMatrix4x4 M)` Méthode qui effectue le produit matriciel entre deux matrices.
`SVector4d`	`multiply(SVector3d v)` Méthode qui effectue le produit entre une matrice 4x4 et un vecteur colonne en 3d dont une 4ième dimension t = 1.0 est ajoutée.
`SVector4d`	`multiply(SVector4d v)` Méthode qui effectue le produit entre une matrice 4x4 et un vecteur colonne en 4d.
`static SMatrix4x4`	`rotationU(SVector3d u, double angle)` Méthode pour obtenir une matrice de transformation linéaire de rotation Ru autour d'un axe u quelconque par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre v1 = Ru * v0 où v0 est le vecteur à transformer et v1 est le vecteur transformé.
`static SMatrix4x4`	`rotationX(double degree)` Méthode pour obtenir une matrice de transformation linéaire de rotation Rx autour de l'axe x par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre u = Rx * v
`static SMatrix4x4`	`rotationY(double degree)` Méthode pour obtenir une matrice de transformation linéaire de rotation Ry autour de l'axe y par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre u = Ry * v
`static SMatrix4x4`	`rotationZ(double degree)` Méthode pour obtenir une matrice de transformation linéaire de rotation Rz autour de l'axe z par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre u = Rz * v
`static SMatrix4x4`	`Rxyz(SVector3d v)` Méthode pour obtenir une matrice de transformation linéaire de rotation Rxyz autour des axes successifs z, y et x par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre u = Rxyz * v
`static SMatrix4x4`	`Rzyx(SVector3d v)` Méthode pour obtenir une matrice de transformation linéaire de rotation Rzyx autour des axes successifs x, y et z par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre u = Rzyx * v
`static SMatrix4x4`	`scale(double sc_x, double sc_y, double sc_z)` Méthode pour obtenir une matrice de transformation linéaire d'homothétie Sc (scale) par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre u = Sc * v
`static SMatrix4x4`	`scale(SVector3d v)` Méthode pour obtenir une matrice de transformation linéaire d'homothétie Sc (scale) par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre u = Sc * v
`static SMatrix4x4`	`ScRxyzTr(SVector3d scale, SVector3d rotation, SVector3d translation)` Méthode pour obtenir une matrice de transformation linéaire de translation Tr, de rotation Rxyz autour des axes successifs z, y et x puis d'homothétie Sc (scale) par rapport à l'origine d'un système d'axe cartésien xyz.
`java.lang.String`	`toString()`
`static SMatrix4x4`	`translation(double tr_x, double tr_y, double tr_z)` Méthode pour obtenir une matrice de transformation linéaire de translation Tr par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre u = Tr * v
`static SMatrix4x4`	`translation(SVector3d v)` Méthode pour obtenir une matrice de transformation linéaire de translation Tr par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre u = Tr * v
`SMatrix4x4`	`transpose()` Méthode pour obtenir la matrice transposée de la matrice qui lance l'appel de cette méthode.
`static SMatrix4x4`	`TrRzyxSc(SVector3d translation, SVector3d rotation, SVector3d scale)` Méthode pour obtenir une matrice de transformation linéaire d'homothétie Sc (scale), de rotation Rzyx autour des axes successifs x, y et z puis de translation Tr par rapport à l'origine d'un système d'axe cartésien xyz.

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - SMatrix4x4
```
public SMatrix4x4()
```
    Constructeur de la matrice nulle (tous les éléments M[i][j] seront nuls.)
  - SMatrix4x4
```
public SMatrix4x4(double m00,
                  double m01,
                  double m02,
                  double m03,
                  double m10,
                  double m11,
                  double m12,
                  double m13,
                  double m20,
                  double m21,
                  double m22,
                  double m23,
                  double m30,
                  double m31,
                  double m32,
                  double m33)
```
    Constructeur d'une matrice 4x4 avec paramètres en coordonnée M[i][j] tel que i correspond à la ligne et j correspond à la colonne. Visuellement, l'organisation des données correspond à la matrice suivante :
    M = | m00 m01 m02 m03 |
    Parameters:
    
    m00 - - L'élément 00 de la matrice (colonne 1 : ligne 1)
    
    m01 - - L'élément 01 de la matrice (colonne 2 : ligne 1)
    
    m02 - - L'élément 02 de la matrice (colonne 3 : ligne 1)
    
    m03 - - L'élément 03 de la matrice (colonne 4 : ligne 1)
    
    m10 - - L'élément 10 de la matrice (colonne 1 : ligne 2)
    
    m11 - - L'élément 11 de la matrice (colonne 2 : ligne 2)
    
    m12 - - L'élément 12 de la matrice (colonne 3 : ligne 2)
    
    m13 - - L'élément 13 de la matrice (colonne 4 : ligne 2)
    
    m20 - - L'élément 20 de la matrice (colonne 1 : ligne 3)
    
    m21 - - L'élément 21 de la matrice (colonne 2 : ligne 3)
    
    m22 - - L'élément 22 de la matrice (colonne 3 : ligne 3)
    
    m23 - - L'élément 23 de la matrice (colonne 4 : ligne 3)
    
    m30 - - L'élément 30 de la matrice (colonne 1 : ligne 4)
    
    m31 - - L'élément 31 de la matrice (colonne 2 : ligne 4)
    
    m32 - - L'élément 32 de la matrice (colonne 3 : ligne 4)
    
    m33 - - L'élément 33 de la matrice (colonne 4 : ligne 4)
- Method Detail
  - multiply
```
public SMatrix4x4 multiply(SMatrix4x4 M)
```
    Méthode qui effectue le produit matriciel entre deux matrices. La matrice M1 qui lance l'appel de cette méthode sera la matrice de gauche et la matrice M2 passée en paramètre sera la matrice de droite. Cette précision est nécessaire étant donné que le produit matriciel n'est pas commutatif.
    Le résutat du produit matriciel M = M1*M2 correspond au calcul
    où M[i][j] est une composantes de la matrice M.
    Parameters:
    
    M - - La matrice M2 de droite à multiplier avec la matrice M1 lançant l'appel de la méthode.
    
    Returns:
    
    Le résultat M du produit matriciel.
  - multiply
```
public SVector4d multiply(SVector4d v)
```
    Méthode qui effectue le produit entre une matrice 4x4 et un vecteur colonne en 4d. La matrice M qui lance l'appel de cette méthode sera à gauche et le vecteur colonne passé en paramètre sera à droite. Cette précision est nécessaire étant donné que le produit entre une matrice et un vecteur n'est pas commutatif.
    Le résutat du produit matriciel u = M*v correspond au calcul
    où u[i] est une composantes du vecteur colonne u.
    Parameters:
    
    v - - Le vecteur de droite à multiplier avec la matrice qui lance l'appel de la méthode.
    
    Returns:
    
    Le vecteur colonne u étant le résultat du produit de la matrice M avec le vecteur colonne v.
  - multiply
```
public SVector4d multiply(SVector3d v)
```
    Méthode qui effectue le produit entre une matrice 4x4 et un vecteur colonne en 3d dont une 4ième dimension t = 1.0 est ajoutée. La matrice M qui lance l'appel de cette méthode sera à gauche et le vecteur colonne passé en paramètre sera à droite. Cette précision est nécessaire étant donné que le produit entre une matrice et un vecteur n'est pas commutatif.
    Le résutat du produit matriciel u = M*v correspond au calcul
    où u[i] est une composantes du vecteur colonne u.
    Parameters:
    
    v - - Le vecteur de droite à multiplier avec la matrice qui lance l'appel de la méthode.
    
    Returns:
    
    Le vecteur colonne u étant le résultat du produit de la matrice M avec le vecteur colonne v.
  - identity
```
public static SMatrix4x4 identity()
```
    Méthode pour obtenir la matrice identité I.
    
    Soit une matrice identité I et une matrice A quelconque, alors
    ce qui rend la matrice identité commutative.
    Returns:
    
    La matrice identité I.
  - transpose
```
public SMatrix4x4 transpose()
```
    Méthode pour obtenir la matrice transposée de la matrice qui lance l'appel de cette méthode. La matrice transposée B s'obtient à partir d'une matrice A grâce au calcul
    Returns:
    
    La matrice transposée.
  - translation
```
public static SMatrix4x4 translation(SVector3d v)
```
    Méthode pour obtenir une matrice de transformation linéaire de translation Tr par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v est le vecteur à transformer et u est le vecteur transformé.
    Parameters:
    
    v - - Le vecteur de translation en coordonnée cartésienne.
    
    Returns:
    
    La matrice de translation T.
  - translation
```
public static SMatrix4x4 translation(double tr_x,
                                     double tr_y,
                                     double tr_z)
```
    Méthode pour obtenir une matrice de transformation linéaire de translation Tr par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v est le vecteur à transformer et u est le vecteur transformé.
    Parameters:
    
    tr_x - - La translation selon l'axe x.
    
    tr_y - - La translation selon l'axe y.
    
    tr_z - - La translation selon l'axe z.
    
    Returns:
    
    La matrice de translation T.
  - scale
```
public static SMatrix4x4 scale(SVector3d v)
```
    Méthode pour obtenir une matrice de transformation linéaire d'homothétie Sc (scale) par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v est le vecteur à transformer et u est le vecteur transformé.
    Parameters:
    
    v - - Le vecteur d'homothétie en coordonnée cartésienne.
    
    Returns:
    
    La matrice d'homothétie Sc (scale).
  - scale
```
public static SMatrix4x4 scale(double sc_x,
                               double sc_y,
                               double sc_z)
```
    Méthode pour obtenir une matrice de transformation linéaire d'homothétie Sc (scale) par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v est le vecteur à transformer et u est le vecteur transformé.
    Parameters:
    
    sx - - L'homothétie selon l'axe x.
    
    sy - - L'homothétie selon l'axe y.
    
    sz - - L'homothétie selon l'axe z.
    
    Returns:
    
    La matrice de transformation d'homothétie Sc (scale).
  - rotationX
```
public static SMatrix4x4 rotationX(double degree)
```
    Méthode pour obtenir une matrice de transformation linéaire de rotation Rx autour de l'axe x par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v est le vecteur à transformer et u est le vecteur transformé.
    Parameters:
    
    degree - - L'angle de rotation en degré.
    
    Returns:
    
    La matrice de rotation Rx autour de l'axe x.
  - rotationY
```
public static SMatrix4x4 rotationY(double degree)
```
    Méthode pour obtenir une matrice de transformation linéaire de rotation Ry autour de l'axe y par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v est le vecteur à transformer et u est le vecteur transformé.
    Parameters:
    
    degree - - L'angle de rotation en degré.
    
    Returns:
    
    La matrice de rotation Ry autour de l'axe y.
  - rotationZ
```
public static SMatrix4x4 rotationZ(double degree)
```
    Méthode pour obtenir une matrice de transformation linéaire de rotation Rz autour de l'axe z par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v est le vecteur à transformer et u est le vecteur transformé.
    Parameters:
    
    degree - - L'angle de rotation en degré.
    
    Returns:
    
    La matrice de rotation Rz autour de l'axe z.
  - rotationU
```
public static SMatrix4x4 rotationU(SVector3d u,
                                   double angle)
                            throws SImpossibleNormalizationException
```
    Méthode pour obtenir une matrice de transformation linéaire de rotation Ru autour d'un axe u quelconque par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v0 est le vecteur à transformer et v1 est le vecteur transformé. Dans la littérature, cette matrice porte le nom de matrice des cosinus directionnels (direction cosine matrix).
    Parameters:
    
    u - L'axe de rotation (doit être unitaire).
    
    angle - L'angle de rotation en degré.
    
    Returns:
    
    La matrice de rotation autour de l'axe u.
    
    Throws:
    
    SImpossibleNormalizationException - Si l'axe de rotation u ne peut pas être normalisé.
  - Rzyx
```
public static SMatrix4x4 Rzyx(SVector3d v)
```
    Méthode pour obtenir une matrice de transformation linéaire de rotation Rzyx autour des axes successifs x, y et z par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v est le vecteur à transformer et u est le vecteur transformé.
    
    La matrice Rzyx est le résultat de l'opération
    où Rx est la matrice de rotation autour de l'axe x, Ry est la matrice de rotation autour de l'axe y et Rz est la matrice de rotation autour de l'axe z et
    Parameters:
    
    v - - Le vecteur de rotation selon l'axe x,y et z en degré.
    
    Returns:
    
    La matrice de rotation Rzyx dans l'ordre x, y et z si elle est utilisée tel que u = Rzyx*v.
  - Rxyz
```
public static SMatrix4x4 Rxyz(SVector3d v)
```
    Méthode pour obtenir une matrice de transformation linéaire de rotation Rxyz autour des axes successifs z, y et x par rapport à l'origine d'un système d'axe cartésien xyz si la matrice est utilisée dans l'ordre
    où v est le vecteur à transformer et u est le vecteur transformé.
    
    La matrice Rxyz est le résultat de l'opération
    où Rx est la matrice de rotation autour de l'axe x, Ry est la matrice de rotation autour de l'axe y et Rz est la matrice de rotation autour de l'axe z et
    Parameters:
    
    v - - Le vecteur de rotation selon l'axe x,y et z en degré.
    
    Returns:
    
    La matrice de rotation Rxyz dans l'ordre z, y et x si elle est utilisée tel que u = Rxyz*v.
  - TrRzyxSc
```
public static SMatrix4x4 TrRzyxSc(SVector3d translation,
                                  SVector3d rotation,
                                  SVector3d scale)
```
    Méthode pour obtenir une matrice de transformation linéaire d'homothétie Sc (scale), de rotation Rzyx autour des axes successifs x, y et z puis de translation Tr par rapport à l'origine d'un système d'axe cartésien xyz. La matrice TRzyxS est le résultat de l'opération
    et elle doit être utilisée sous la représentation
    où v est le vecteur à transformer et u est le vecteur transformé.
    Parameters:
    
    translation - - Le vecteur représentant la translation selon l'axe x, y et z.
    
    rotation - - Le vecteur rotation autour des avec x, y et z successivement.
    
    scale - - Le vecteur d'homothétie (scale) à appliquer.
    
    Returns:
    
    La matrice de transformation linéaire TrRzyxSc.
  - ScRxyzTr
```
public static SMatrix4x4 ScRxyzTr(SVector3d scale,
                                  SVector3d rotation,
                                  SVector3d translation)
```
    Méthode pour obtenir une matrice de transformation linéaire de translation Tr, de rotation Rxyz autour des axes successifs z, y et x puis d'homothétie Sc (scale) par rapport à l'origine d'un système d'axe cartésien xyz. La matrice ScRxyzTr est le résultat de l'opération
    et elle doit être utilisée sous la représentation
    où v est le vecteur à transformer et u est le vecteur transformé.
    Parameters:
    
    scale - - Le vecteur d'homothétie (scale) à appliquer.
    
    rotation - - Le vecteur rotation autour des avec x, y et z successivement.
    
    translation - - Le vecteur représentant la translation selon l'axe x, y et z.
    
    Returns:
    
    La matrice de transformation linéaire ScRxyzTr.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object

Class SMatrix4x4

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SMatrix4x4

SMatrix4x4

Method Detail

multiply

multiply

multiply

identity

transpose

translation

translation

scale

scale

rotationX

rotationY

rotationZ

rotationU

Rzyx

Rxyz

TrRzyxSc

ScRxyzTr

toString

hashCode

equals