Search  

---

C:/temp/src/j2k/Beta/3D/Model.cpp

Go to the documentation of this file.

#ifndef __J2K__Model_CPP__
#define __J2K__Model_CPP__

#include <j2k/Fred/3d/Model.hpp>

#include <math.h>
#include <alloc.h>
#include <stdlib.h>

/* Graphe Model */
realtype Norme( realtype* v, char mode) {
  double vx = v[_X_] * v[_X_];
  double vy = v[_Y_] * v[_Y_];
  double vz = ( mode == __3D ) ? v[_Z_]*v[_Z_] : 0;

  return sqrt( vx + vy + vz );
}

/* Prof to Prof */
#define __mod_prof_mess_ok    "Translate Modeleur : No error."
#define __mod_prof_mess_mem   "Translate Modeleur : Out of memory."
#define __mod_prof_mess_mess  "Translate Modeleur : Bad mess number"
#define __mod_prof_messdata1  "Translate Modeleur : Cardinal is null."
#define __mod_prof_messdata2  "Translate Modeleur : Bad translate data."

/*  ----------------------------------------------------------------------*/

int    G_Error_Mod_Prof = SUCCESS;

char*  G_Error_Mod_Prof_Mess[] = { 
    __mod_prof_mess_ok,
    __mod_prof_mess_mem,
    __mod_prof_mess_mess,
    __mod_prof_messdata1,
    __mod_prof_messdata2 
};

/*  ----------------------------------------------------------------------*/

int ModeleurProfToProf( 
  Sommet3D*     profil,     /* La table des profils  */
  Sommet3D*     profil1,    /* La table des profils  */
  UINT          NbSommet,   /* Occurence de la table */
  Sommet3D**    sommet,     /* Les sommets crées     */
  UINT*         nbnew,
  GenerateType* type,
  Vector3D      trans,      /* vecteur de translation */
  UINT          pas         /* Nombre de profils      */
)

{
  UINT nbnewsommet,
       borneprofilhaut = 0,
       borneprofilbas  = NbSommet-1,
       i, j,
       compt = 0;

 realtype tx = trans.b.x - trans.a.x,
          ty = trans.b.y - trans.a.y,
          tz = trans.b.z - trans.a.z,
          atx,
          aty,
          atz,
          hom,
          t = 0;

 /* Verification des données */
 /* ------------------------ */
 if ( !NbSommet ) return MOD_PROF_TO_PROF_ERROR_BAD_DATA_CARDINAL;

 if ( !pas || pas == 1 || ( !tx && !ty && !tz ) ) {
    return MOD_PROF_TO_PROF_ERROR_BAD_TRANS_PAR;
 }


 /* On calcul le nombre de nouveaux sommets */
 /* --------------------------------------- */

 /* le profil est il un domaine?.*/
 if ( profil[0].x == profil[ NbSommet -1 ].x &&
      profil[0].y == profil[ NbSommet -1 ].y &&
      profil[0].z == profil[ NbSommet -1 ].z )
 {
    type->pvert = VERT_CLOSE;
    borneprofilbas --;

 } else {
    type->pvert = VERT_OPEN; 
 }


 /* On alloue la table des sommets */
 /* ------------------------------ */
 nbnewsommet = ((type->pvert == VERT_OPEN) ? NbSommet: NbSommet-1) * pas;

 *nbnew = nbnewsommet;
 *sommet = (Sommet3D*) calloc( nbnewsommet, sizeof(Sommet3D) );

 if ( !(*sommet) )  return MOD_PROF_TO_PROF_ERROR_MEMORY;

  /* On commence par copier le profil initial.*/
  /* compt est initialisé à 0.*/

  for( j = borneprofilhaut; j <= borneprofilbas; j++ ) {
    (*sommet)[compt].x = profil[j].x;
    (*sommet)[compt].y = profil[j].y;
    (*sommet)[compt].z = profil[j].z;
    compt++;
  }

  /* On fait une boucle sur les profils restant.*/
  /* t est initialisé à 0.*/

  hom = 1.0/(pas-1);

  for( i = 1; i < pas; i++ ) {
    atx = tx * i;
    aty = ty * i;
    atz = tz * i;
    t += hom;

    for ( j = borneprofilhaut; j <= borneprofilbas; j++ ) {
     (*sommet)[compt].x = profil[j].x + (profil1[j].x - profil[j].x)* t;
     (*sommet)[compt].y = profil[j].y + (profil1[j].y - profil[j].y)* t;
     (*sommet)[compt].z = profil[j].z + (profil1[j].z - profil[j].z)* t;

     TransVertex( (*sommet)+compt, atx, aty, atz );
     compt++;

    } // Next j

  } // Next i

 /* Mise à jour des renseignements sur la forme générée */
 /* --------------------------------------------------- */
 type->ponaxis = 0;
 type->phor    = HOR_OPEN;
 type->type    = SURFACE;

  return SUCCESS; 

} // ModeleurProfToProf

char* GetModelProfToProfErrorMsg( int num ) {

 if ( num >= _cardinamod_prof_to_prof_mess || num < 0 ) {
   return G_Error_Mod_Prof_Mess [MOD_PROF_TO_PROF_ERROR_MSG] 

 } else {
   return G_Error_Mod_Prof_Mess [ num ]; 
 }

}

/*
- Le pas represente le nombre de profil désirés, y compris le profil initial.
*/

/* Modeleurs de rotation */

#define __mod_rot_mess_ok     "Rotational Modeleur : No error."
#define __mod_rot_mess_mem    "Rotational Modeleur : Out of memory."
#define __mod_rot_mess_mess   "Rotational Modeleur : Bad mess number"
#define __mod_rot_messdata1   "Rotational Modeleur : Cardinal is null."
#define __mod_rot_messdata2   "Rotational Modeleur : All vertex on axis."
#define __mod_rot_messdata3   "Rotational Modeleur : Segment find on axis."
#define __mod_rot_messdata4   "Rotational Modeleur : Segment intersect axis."
#define __mod_rot_messdata5   "Rotational Modeleur : Bad rotate data."
#define __mod_rot_messdata6   "Rotational Modeleur : Bad profil combination."

double G_mod_rot_double_precision = 1E-3;

int    G_Error_Mod_Rot = SUCCESS;

char*  G_Error_Mod_Rot_Mess [] = { 
   __mod_rot_mess_ok,
   __mod_rot_mess_mem,
   __mod_rot_mess_mess,
   __mod_rot_messdata1,
   __mod_rot_messdata2,
   __mod_rot_messdata3,
   __mod_rot_messdata4,
   __mod_rot_messdata5,
   __mod_rot_messdata6 
};

UINT ModRotGetCardSommet( UINT nbp, double* angle, UINT pas, char extr )
{

 UINT nb;

 if ( !nbp || pas <= 1 ) return 0;

 /* on recale les angles sur 0-360° */
 while ( *angle >  360 )  angle -= 360;
 while ( *angle < -360 )  angle += 360;

 nb = pas * nbp;

 /* les deux extremités sont sur l'axe */
 if ( extr == EXTR_BOTH ) nb -= ( 2 * (pas-1) );

 /* une seule éxtremité sur l'axe */
 if ( extr == EXTR_SUP || extr == EXTR_INF ) nb -= (pas-1);

 return nb; 
}

int ModeleurRotationZ( 
   Sommet3D*      profil,    /* La table des profils. */
   Sommet3D*      profil1,   /* La table des profils. */
   UINT           NbSommet,  /* Occurence de la table.*/
   Sommet3D**     sommet,    /* Les sommets crées.    */
   UINT*          nbnew,
   GenerateType*  type,
   double         angle,     /* Angle de rotation.    */
   UINT           pas        /* Pas de rotation.      */
) 
{

  int      error;

  char     flagExtr, 
           flagExtr1;

  UINT     nbnewsommet,
           borneprofilhaut,
           borneprofilbas,
           i, j,
           compt = 0, 
           depart = 0;

  double   angle_iteration   = 0, 
           angle = angle,
           cosangle,
           sinangle;

  UINT      sameprofil = OFF;

  realtype  t = 0, hom;

  /* Verification de la cohérence des données */
  /* ---------------------------------------- */
  if ( profil == profil1 )
     sameprofil = ON;

  if ( (error = CheckingProfilRotationZ(
         profil,  NbSommet, &flagExtr  )) != SUCCESS ) return error;

  if ( sameprofil == OFF ) {
    if ( (error = CheckingProfilRotationZ( 
         profil1, NbSommet, &flagExtr1 )) != SUCCESS ) return error;

    if ( flagExtr != flagExtr1 )
      return MOD_ROT_ERROR_BAD_PROFIL_COMBINATION;
  }

  /* Determine les bornes de traitement pour la generation */

  borneprofilhaut = ( flagExtr == EXTR_SUP  ||
                      flagExtr == EXTR_BOTH ) ? (1) : (0);

  borneprofilbas  = ( flagExtr == EXTR_INF  ||
                      flagExtr == EXTR_BOTH ) ? (NbSommet-2) : (NbSommet-1);

  /* les profils sont-ils des domaines ? */
  if ( profil[0].x == profil[ NbSommet -1 ].x &&
       profil[0].y == profil[ NbSommet -1 ].y &&
       profil[0].z == profil[ NbSommet -1 ].z )
  {
     type->pvert = VERT_CLOSE;
     borneprofilbas --;
  } else {
     type->pvert = VERT_OPEN;
  }

  if ( profil1[0].x == profil1[ NbSommet -1 ].x &&
       profil1[0].y == profil1[ NbSommet -1 ].y &&
       profil1[0].z == profil1[ NbSommet -1 ].z )
  {
     if ( type->pvert != VERT_CLOSE )
         return MOD_ROT_ERROR_BAD_PROFIL_COMBINATION;

  } else 
     if ( type->pvert != VERT_OPEN )
         return MOD_ROT_ERROR_BAD_PROFIL_COMBINATION;

  /* On alloue la table  des sommets */
  /* ------------------------------- */
  nbnewsommet = ModRotGetCardSommet(
      ( type->pvert == VERT_OPEN ) ? (NbSommet) : (NbSommet-1),
      &angle, pas, flagExtr
  );

  if ( !nbnewsommet ) return MOD_ROT_ERROR_BAD_ROTATE_PAR;

  *nbnew = nbnewsommet;
  *sommet = (Sommet3D*) calloc( nbnewsommet, sizeof( Sommet3D ) );

  if ( !(*sommet) )  return MOD_ROT_ERROR_MEMORY;

  if ( fabs(angle) != COMPLETE_ROTATE&& sameprofil == ON ) {
    angle_iteration = DegreeToRad( angle / (pas-1) );

  } else {
    angle_iteration = DegreeToRad( angle / pas );
  }

  /* Nb - pas -1 car le profil initial est dejas compris.*/

  /* On commence par copier le profil initial.*/
  /* compt est initialisé à 0.*/

  for( j = borneprofilhaut; j <= borneprofilbas; j++ ) {
    (*sommet)[compt].x = profil[j].x;
    (*sommet)[compt].y = profil[j].y;
    (*sommet)[compt].z = profil[j].z;
    compt++;
  }

  /* On fait une boucle sur les profils restant */
  /* depart est initialisé a 0 */

  hom = 1.0/(pas-1);

  for( i = 1; i < pas; i++ ) {
    t += hom;
    cosangle = cos(angle_iteration*i);
    sinangle = sin(angle_iteration*i);

    for( j = borneprofilhaut; j <= borneprofilbas; j++ ) {

      (*sommet)[compt].x = profil[j].x + (profil1[j].x - profil[j].x)* t;
      (*sommet)[compt].y = profil[j].y + (profil1[j].y - profil[j].y)* t;
      (*sommet)[compt].z = profil[j].z + (profil1[j].z - profil[j].z)* t;

      RotateVertex( (*sommet)+compt, cosangle, sinangle, Z_AXIS );
      compt++;
      depart++;

    } // Next j

    depart = 0;

  } // Next i

  /* on rajoute si necessaire, les points sur l'axe.*/
  if ( flagExtr == EXTR_SUP  || flagExtr == EXTR_BOTH ) {
     (*sommet)[compt].x = profil[0].x;
     (*sommet)[compt].y = profil[0].y;
     (*sommet)[compt].z = profil[0].z;
     compt++;
  }

  if ( flagExtr == EXTR_INF || flagExtr == EXTR_BOTH ) {
     (*sommet)[compt].x = profil[NbSommet-1].x;
     (*sommet)[compt].y = profil[NbSommet-1].y;
     (*sommet)[compt].z = profil[NbSommet-1].z;
  }

 /* Mise à jour des renseignements sur la forme générée */
 /* --------------------------------------------------- */
 type->ponaxis = flagExtr;

 type->phor    = (angle == COMPLETE_ROTATE && sameprofil == ON ) ?
                     HOR_CLOSE : HOR_OPEN;

 type->type    = ( type->phor == HOR_CLOSE &&
                   ( type->ponaxis == EXTR_BOTH ||
                     type->pvert   == VERT_CLOSE    )
                  ) ? VOLUME : SURFACE;

  return SUCCESS; 
}

/* macros locales à la fonction CheckingProfilRotationZ(....)*/
#define __Test_0(v) ( i == 0 ) ? ( v ) > 0 : (v) >= 0
#define __Test_1(v) ( i == NbSommet-2 ) ? (v) < 1 : (v) <= 1

int CheckingProfilRotationZ( 
    Sommet3D*  profil,    /* La table des profils  */
    UINT       NbSommet,  /* Occurence de la table */
    char*      flagExtr   /* Sommets sur l'axe ?   */
)

{
 char  flag1 = EXTR_NONE,  /* flag premier sommet sur l'axe.*/
       flag2 = EXTR_NONE,  /* flag dernier sommet sur l'axe.*/
       flag  = OFF;        /* Il y a t'il un sommet hors axe.*/

 UINT    i,  
         r1, r2;            /* compteur boucle.       */

 double  t1, t2,            /* Parametres de segment. */
         temp1,             /* Var intermediaires.    */
         temp2;             /* "     "      "         */

/* On verifie la cohérence des données.
//  Le profil est il suceptible de generer quelque chose de correct autour
//  de l'axe Z ?
//  Pour ce faire, il doit :
//    - Avoir un nombre de sommet different de zero.
//    - Avoir au moins un sommet non confondus avec l'axe.
//    - Tous ses sommets doivent se trouver dans le même demis plans
//      limité par l'axe Z. Cela se resume par le fait qu'aucun
//      segment ne doit couper directement l'axe zz'. Soit le segment
//      projeté sur le plans xy ne doit pas renfermer le point m(0,0).
//      On rappelle la définition paramétrique d'un segment :
//      P(t) = P1 + (P2-P1)t;
//      d'ou avec l'axe corespondant on as : t = -P1 / (P2-P1);
//      Si t appartient à [0,1], alors il y a intersection.
//      Dans le cas qui nous interesse, appartenance du point m(0,0)
//      a un segment ab, on obtient le système suivant:
//          0 = Xa + ( Xb - Xa )* T1
//          0 = Ya + ( Yb - Ya )* T2
//      m appartient à ab si T1 = T2 et   T1 appartient à [0,1].
//      nb : reste les cas particulier ou Xb-Xa = 0 ou Yb-Ya = 0.
*/

*flagExtr = EXTR_NONE;

 if ( !NbSommet ) return MOD_ROT_ERROR_BAD_DATA_CARDINAL;

 /* On regarde si le profil est fermé sur l'axe.         */
 /* nb - IsOnAxe(...) est une fonction definie plus bas. */
 /* on verifi qu'il y a au moins un sommet hors axe.     */
 /* ---------------------------------------------------- */

 /* Le point initial.*/
 if ( IsOnAxe( profil[0].x, profil[0].y ) ) {
   flag1 = EXTR_SUP;

 } else {
   flag = ON; 
 }

 /* les point intermediaires.*/
 for( i = 1; i < NbSommet-1; i ++ )
   if ( !IsOnAxe( profil[i].x, profil[i].y ) ) {
     flag = ON; 
     break; 
   }

 /* Le point final.*/
 if ( IsOnAxe( profil[NbSommet-1].x, profil[NbSommet-1].y) ) {
   flag2 = EXTR_INF;
 } else {
   flag = ON;
 }

 if ( flag == OFF ) return MOD_ROT_ERROR_BAD_DATA_OUT_AXIS;

 /* Verification de tous les arcs */
 /* ----------------------------- */
 for( i = 0; i < NbSommet-1; i++ ) {
   temp1 = profil[i+1].x - profil[i].x;
   temp2 = profil[i+1].y - profil[i].y;
   t1    = -profil[i].x;
   t2    = -profil[i].y;

   /* On elimine le cas trivial de segment confondu avec l'axe de rotation*/
   /* et du même coup, celui des segments parallele à l'axe.              */
   /* --------------------------------------------------------------------*/
   if ( ! temp1&& ! temp2 )
       if ( !t1&& !t2 ) return MOD_ROT_ERROR_BAD_DATA_ON_AXIS;
    else  continue;

    /* Nb- __Test_0 et __Test_1 sont des macro declarées plus haut qui
     * eliminent les cas où l'intersection des premier et dernier segment
     * provient de la fermeture du profil sur l'axe. */
    /* On elimine le cas trivial de segment parallele avec l'axe yy'*/
    /* -------------------------------------------------------------*/
    if ( ! temp1 )
      if ( !t1 ) {
        t2 /= temp2;
        r1 = __Test_0(t2);
        r2 = __Test_1(t2);
        if ( r1&& r2 ) return MOD_ROT_ERROR_BAD_DATA_INTER;
        continue;
      }
     else  continue;

     /* On elimine le cas trivial des segments paralleles avec l'axe xx'*/
     /* ----------------------------------------------------------------*/
     if ( ! temp2 )
       if ( !t2 )
         {
         t1 /= temp1;
         r1 = __Test_0(t1);
         r2 = __Test_1(t1);
         if ( r1&& r2 ) return MOD_ROT_ERROR_BAD_DATA_INTER;
         continue;
         }
     else  continue;

     /* On cherche l'intersection.*/
     /* ---------------------------*/
     t1 /= temp1;
     t2 /= temp2;

     r1 = __Test_0(t1);
     r2 = __Test_1(t1);
     if ( ( t1 == t2  ) &&  r1&& r2  )
        return MOD_ROT_ERROR_BAD_DATA_INTER;
     }

/* A ce niveau tout est OK. On peut generer les sommets.*/
/* -----------------------------------------------------*/

 *flagExtr = flag1+flag2;

 return SUCCESS;
}

#undef __test_0
#undef __test_1

char* GetModelRotatErrorMsg( int num ) {
 return ( num >= _cardinamod_rot_mess || num < 0 ) ?
    G_Error_Mod_Rot_Mess [MOD_ROT_ERROR_MSG] :
    G_Error_Mod_Rot_Mess [ num ]; }

int IsOnAxe ( double a, double b ) {
 return ( fabs(a) <= G_mod_rot_double_precision &&
          fabs(b) <= G_mod_rot_double_precision  );
}


/* Modeleurs de translation */

#define __mod_rot_mess_ok     "Translate Modeleur : No error."
#define __mod_rot_mess_mem    "Translate Modeleur : Out of memory."
#define __mod_rot_mess_mess   "Translate Modeleur : Bad mess number"
#define __mod_rot_messdata1   "Translate Modeleur : Cardinal is null."
#define __mod_rot_messdata2   "Translate Modeleur : Bad translate data."

int    G_Error_Mod_Trans = SUCCESS;

char*  G_Error_Mod_Trans_Mess[] = { 
      __mod_rot_mess_ok,
      __mod_rot_mess_mem,
      __mod_rot_mess_mess,
      __mod_rot_messdata1,
      __mod_rot_messdata2 
};

/*
- Le pas represente le nombre de profil désirés, y compris le profil initial.
*/

int ModeleurTranslation( 
   Sommet3D*      profil,   /* La table des profils.  */
   UINT           NbSommet, /* Occurence de la table. */
   Sommet3D**     sommet,   /* Les sommets crées.     */
   UINT*          nbnew,
   GenerateType*  type,
   Vector3D       trans,    /* vecteur de translation.*/
   UINT           pas       /* Nombre de profils      */
) {

 UINT       nbnewsommet,
            borneprofilhaut = 0,
            borneprofilbas = NbSommet-1,
            i, j,
            compt = 0,
            depart = 0;

 realtype   tx = trans.b.x - trans.a.x,
            ty = trans.b.y - trans.a.y,
            tz = trans.b.z - trans.a.z,
            atx,
            aty,
            atz;

 /* Verification des données */
 /* ------------------------ */
 if ( !NbSommet ) return MOD_TRAN_ERROR_BAD_DATA_CARDINAL;


 if ( !pas || ( !tx && !ty && !tz ) )
    return MOD_TRAN_ERROR_BAD_TRANS_PAR;

 /* On calcul le nombre de nouveaux sommets */
 /* --------------------------------------- */

 /* Le profil est-il un domaine ? */
 if ( profil[0].x == profil[ NbSommet -1 ].x &&
      profil[0].y == profil[ NbSommet -1 ].y &&
      profil[0].z == profil[ NbSommet -1 ].z )
 {
    type->pvert = VERT_CLOSE;
    borneprofilbas --;

 } else {
    type->pvert = VERT_OPEN;
 }


 /* On alloue la table  des sommets */
 /* ------------------------------- */
  nbnewsommet = ( (type->pvert == VERT_OPEN) ?
                  (NbSommet): (NbSommet-1) ) * pas;

 *nbnew = nbnewsommet;
 *sommet = (Sommet3D*) calloc( nbnewsommet, sizeof(Sommet3D) );
  if ( !(*sommet) )  return MOD_TRAN_ERROR_MEMORY;

  /* On commence par copier le profil initial.*/
  /* compt est initialisé à 0.*/

  for ( j = borneprofilhaut; j <= borneprofilbas; j++ ) {
    (*sommet)[compt].x = profil[j].x;
    (*sommet)[compt].y = profil[j].y;
    (*sommet)[compt].z = profil[j].z;
    compt++;
  }

  /* On fait une boucle sur les profils restant.*/
  /* depart est initialisé a 0.*/

  for( i = 1; i < pas; i++ ) {
    atx = tx * i;
    aty = ty * i;
    atz = tz * i;

    for( j = borneprofilhaut; j <= borneprofilbas; j++ ) {
      (*sommet)[compt].x = (*sommet)[depart].x;
      (*sommet)[compt].y = (*sommet)[depart].y;
      (*sommet)[compt].z = (*sommet)[depart].z;

      TransVertex( (*sommet)+compt, atx, aty, atz );

      compt++;
      depart++;

    } // Next j

    depart = 0;

  } // Next i

 /* Mise à jour des renseignements sur la forme générée */
 /* --------------------------------------------------- */
 type->ponaxis = 0;
 type->phor    = HOR_OPEN;
 type->type    = SURFACE;

  return SUCCESS;
}

char* GetModelTransErrorMsg( int num ) {
 if ( num >= _cardinamod_trans_mess || num < 0 ) {
   return G_Error_Mod_Trans_Mess [MOD_TRAN_ERROR_MSG];

 } else {
   return G_Error_Mod_Trans_Mess [ num ]; 
 }

}


// Modeleurs de translation de profil sur une suite de vecteurs.

#define __mod_vec_mess_ok     "Vector Modeleur : No error."
#define __mod_vec_mess_mem    "Vector Modeleur : Out of memory."
#define __mod_vec_mess_mess   "Vector Modeleur : Bad mess number"
#define __mod_vec_messdata1   "Vector Modeleur : Cardinal is null."
#define __mod_vec_messdata2   "Vector Modeleur : Bad data."

/*////////////////////////////////////////////////////////////////////////////*/

int    G_Error_Mod_Vector  = SUCCESS;

char*  G_Error_Mod_Vector_Mess[] = { 
   __mod_vec_mess_ok,
   __mod_vec_mess_mem,
   __mod_vec_mess_mess,
   __mod_vec_messdata1,
   __mod_vec_messdata2 
};

// - Le vecteur initial normal au profil est le vecteur[0].

int ModeleurVector(
   Sommet3D*      profil,   /* La table des profils.  */
   UINT           NbSommet, /* Occurence de la table. */
   Sommet3D**     sommet,   /* Les sommets crées.     */
   UINT*          nbnew,
   GenerateType*  type,
   Vector3D*      trans,    /* vecteurs de translation.*/
   UINT           nbvec     /* Nombre de profils      */
) {

  UINT      nbnewsommet,
            borneprofilhaut = 0,
            borneprofilbas  = NbSommet-1,
            i, j,
            compt = 0,
            depart = 0;

 /* Verification des données */
 /* ------------------------ */
 if ( !NbSommet ) return MOD_VEC_ERROR_BAD_DATA_CARDINAL;
 if ( !nbvec    ) return MOD_VEC_ERROR_BAD_TRANS_PAR;

 realtype   tx, ty, tz;

 for( i = 0; i != nbvec; i++ ) {

    tx = trans[i].b.x - trans[i].a.x;
    ty = trans[i].b.y - trans[i].a.y;
    tz = trans[i].b.z - trans[i].a.z;
    if ( !tx && !ty && !tz )
       return MOD_VEC_ERROR_BAD_TRANS_PAR;
    }

 /* On calcul le nombre de nouveaux sommets */
 /* --------------------------------------- */

 /* Le profil est-il un domaine ? */
 if ( profil[0].x == profil[ NbSommet -1 ].x&&
      profil[0].y == profil[ NbSommet -1 ].y&&
      profil[0].z == profil[ NbSommet -1 ].z )
 {
    type->pvert = VERT_CLOSE;
    borneprofilbas --;

 } else {
    type->pvert = VERT_OPEN;
 }

 nbnewsommet = ( (type->pvert == VERT_OPEN) ? (NbSommet): (NbSommet-1)
               ) * nbvec;

 /* On alloue la table des sommets */
 /* ------------------------------ */

  *nbnew = nbnewsommet;
  *sommet = (Sommet3D*) calloc ( nbnewsommet, sizeof(Sommet3D) );

  if ( !(*sommet) )  return MOD_VEC_ERROR_MEMORY;

  /* On commence par copier le profil initial.*/
  /* compt est initialisé à 0.*/

  for ( j = borneprofilhaut; j <= borneprofilbas; j++ ) {
    (*sommet)[compt].x = profil[j].x;
    (*sommet)[compt].y = profil[j].y;
    (*sommet)[compt].z = profil[j].z;
    compt++;
  }

  /* pour recuperer les sin et cos des angles entre les vecteurs successif
     ( le vecteur [0] est le vecteur initial de base ), on recupere les sin
     et cos directeur des 2 vecteurs et l'on en determine la difference par
     sin(a-b) = sin(a)cos(b)-cos(a)sin(b).
     cos(a-b)*cos(a-b) = 1 - sin(a-b)*sin(a-b).
  */

  realtype      sinalpha,  cosalpha,
                sinbeta,   cosbeta,
                lgr,
                x, y, z,
                xt, yt, zt,
                sinalpha1, cosalpha1,
                sinbeta1,  cosbeta1,
                sinalpha2, cosalpha2,
                sinbeta2,  cosbeta2,
                lgr1,
                x1, y1, z1;

  xt = trans[0].a.x;
  yt = trans[0].a.y;
  zt = trans[0].a.z;

  x =  trans[0].b.x - trans[0].b.x;
  y =  trans[0].b.y - trans[0].b.y;
  z =  trans[0].b.z - trans[0].b.z;

  lgr = sqrt( x*x + y*y + z*z );

  sinalpha = (z == 0) ? (0) : (lgr/z);
  cosalpha = sqrt( 1 - sinalpha * sinalpha );

  sinbeta  = (x == 0) ? (0) : (lgr/x);
  cosbeta  = sqrt( 1 - sinbeta  * sinbeta  );

  /* On fait une boucle sur les profils restants. */
  /* départ est initialisé a 0.                   */

  for( i = 1; i < nbvec; i++ ) {
    x1 =  trans[i].b.x - trans[i].b.x;
    y1 =  trans[i].b.y - trans[i].b.y;
    z1 =  trans[i].b.z - trans[i].b.z;

    lgr1 = sqrt( x1*x1 + y1*y1 + z1*z1 );

    sinalpha1 = (z1 == 0)?(0):(lgr1/z1);
    cosalpha1 = sqrt(1-sinalpha1*sinalpha1);
    sinbeta1  = (x1 == 0)?(0):(lgr1/x1);
    cosbeta1  = sqrt(1-sinbeta1*sinbeta1);

    sinalpha2 = sinalpha*cosalpha1 - sinalpha1*cosalpha;
    cosalpha2 = sqrt(1 - sinalpha2*sinalpha2);
    sinbeta2 = sinbeta*cosbeta1 - sinbeta1*cosbeta;
    cosbeta2 = sqrt(1 - sinbeta2*sinbeta2);

    for( j = borneprofilhaut; j <= borneprofilbas; j++ ) {
       (*sommet)[compt].x = (*sommet)[depart].x;
       (*sommet)[compt].y = (*sommet)[depart].y;
       (*sommet)[compt].z = (*sommet)[depart].z;

       /* on ramène le vecteur initial en O.*/
       TransVertex( (*sommet)+compt, -xt, -yt, -zt );

       /* les rotations.*/
       RotateVertex( (*sommet)+compt, cosalpha2, sinalpha2, Z_AXIS);
       RotateVertex( (*sommet)+compt, cosbeta2, sinbeta2, X_AXIS);

       /* on translate sur le vecteur desiré.*/
       TransVertex( (*sommet)+compt, 
                     trans[i].a.x,
                     trans[i].a.y,
                     trans[i].a.z  );

           compt++;
           depart++;

    } // Next j

    depart = 0;

 } // Next i

 /* Mise à jour des renseignements sur la forme générée.*/
 /* ----------------------------------------------------*/
 type->ponaxis = 0;
 type->phor    = HOR_OPEN;
 type->type    = SURFACE;

 return SUCCESS; 
}


char* GetModelVectorErrorMsg( int num ) {

 if ( num >= _cardinamod_vec_mess || num < 0 ) {
   return G_Error_Mod_Vector_Mess [MOD_VEC_ERROR_MSG];

 } else {
   return G_Error_Mod_Vector_Mess [ num ]; 
 }

}

#endif  // __J2K__Model_CPP__

---