Search  

---

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

Go to the documentation of this file.

#include <j2k/Fred/3d/Modeleur.hpp>
#include <j2k/Fred/3d/Model.hpp>
#include "boite.h"

#include <string.h>
#include <math.h>

#define __modeopen_fic_error  "Modeleur : Bad File open."
#define __modewrite_fic_error "Modeleur : Bad File write."

char* G_defaultname = "__modelx";

char* G_modetbmsg[] = { 
  __modeopen_fic_error,
  __modewrite_fic_error
};

AxisCAO::AxisCAO ( 
  char*        name,
  Cardinal     c,
  Sommet3D*    pf,
  Vector3D&    v,
  UINT         p

) : cardprofil( c  ),
    profil(     pf ),
    axis(       v  ),
    pas(        p  )
{ 

  if ( name == NULL ) { 
    strcpy(name, G_defaultname); 

  } else {
    strcpy(name, name); 
  }

}

int AxisCAO::GenerateArc( FILE* f ) 
{
  numerotation* n = AllocNumerotation();
  int error;

  if ( fprintf ( f, "%u\n", n->CardinalArc() ) == EOF )
   return (globalresult.error = MOD_SOM_ERROR_BAD_FIC_WRITE );

  if ( (error =  numerotation::NumArc( *n, f ) ) != SUCCESS )
    return globalresult.error =error;

  globalresult.cardarc = n->CardinalArc();

  delete n;

  return SUCCESS; 
}

int AxisCAO::GenerateFace( FILE* f ) 
{ 
  numerotation* n = AllocNumerotation();
  int error;

  if ( fprintf ( f, "%u\n", n->CardinalFace() ) == EOF )
    return globalresult.error =MOD_SOM_ERROR_BAD_FIC_WRITE;

  if ( (error =  numerotation::NumFace(*n, f ) ) != SUCCESS )
    return globalresult.error =error;

  globalresult.cardface = n->CardinalFace();

  delete n;

  return SUCCESS; 
}


int RotProfToProfAxisCAO::GenerateVertex( FILE* f )
{
  int           error;
  Sommet3D*     tbl;
  UINT          card;

  realtype      sinalpha, cosalpha,
                sinbeta,  cosbeta,
                lgr, x, y, z;

  x =  axis.b.x - axis.a.x;
  y =  axis.b.y - axis.a.y;
  z =  axis.b.z - axis.a.z;
  lgr = sqrt( x*x + y*y + z*z );

  /* 90-beta; 90-alpha;*/

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

  // on effectue les changements de repere vers l'axe Z.
  // ---------------------------------------------------

  for( UINT i = 0; i != cardprofil; i++ ) {
    TransVertex ( profil+i, -axis.a.x, -axis.a.y, -axis.a.z );
    RotateVertex( profil+i, cosbeta, sinbeta, Z_AXIS );
    RotateVertex( profil+i, cosalpha, -sinalpha, Y_AXIS );
  };

  // on génère la forme.
  // -------------------
  if ( ( error = ModeleurRotationZ( 
         profil,
         profil1,
         (UINT) cardprofil,
         &tbl,
         &card,
         &(globalresult.type),
        angle,
        pas        

      ) ) != SUCCESS ) return globalresult.error =error;

  // On retransforme en inverse.
  // --------------------------
  // nb- On rappelle : cos(-a) = cos (a) et sin(-a) = -sin(a).
  // ---------------------------------------------------------
  for ( i = 0; i != card; i++ )
      {
      RotateVertex( tbl+i, cosalpha, sinalpha, Y_AXIS );
      RotateVertex( tbl+i, cosbeta, -sinbeta, Z_AXIS );
      TransVertex ( tbl+i, axis.a.x, axis.a.y, axis.a.z );
      }
  for ( i = 0; i != cardprofil; i++ )
      {
      RotateVertex( profil+i, cosalpha, sinalpha, Y_AXIS );
      RotateVertex( profil+i, cosbeta, -sinbeta, Z_AXIS );
      TransVertex ( profil+i, axis.a.x, axis.a.y, axis.a.z );
      }

  // La boite limite.
  // ----------------
  BoiteLim  bl;
  SetBoiteLimite( tbl, card,&bl );

  // On sauve sur fichier.
  // ---------------------
  if ( fprintf ( f, "%f %f %f %f %f %f\n%u\n", bl.S1.x,
                     bl.S1.y,
                     bl.S1.z,
                     bl.S2.x,
                     bl.S2.y,
                     bl.S2.z,
                     card    ) == EOF )
          return globalresult.error =MOD_SOM_ERROR_BAD_FIC_WRITE;

  for ( i = 0; i != card; i++ )
      if ( fprintf ( f, "%lf %lf %lf\n", tbl[i].x,
                   tbl[i].y,
                   tbl[i].z   ) == EOF )
   return globalresult.error =MOD_SOM_ERROR_BAD_FIC_WRITE;

  fprintf ( f, "\n" );

  // on met à jour les renseignements.
  // ---------------------------------
  globalresult.cardsommet    = card;

  return SUCCESS; }

numerotation* RotProfToProfAxisCAO::AllocNumerotation()
{
if ( globalresult.type.phor == HOR_CLOSE )
   {
   if ( globalresult.type.pvert == VERT_OPEN )
      switch ( globalresult.type.ponaxis )
     {
   case EXTR_BOTH : return new FermeOuvertOnAxisBoth(pas-1,cardprofil-1);
   case EXTR_SUP  : return new FermeOuvertOnAxisSup(pas-1,cardprofil-1);
   case EXTR_INF  : return new FermeOuvertOnAxisInf(pas-1,cardprofil-1);
   default        : return new FermeOuvert(pas-1,cardprofil-1) ;
     }
   return new FermeFerme(pas-1,cardprofil-2); // le dernier point
                      //  est suprimé !!!
   }

 if ( globalresult.type.pvert == VERT_CLOSE )
    return new OuvertFerme(pas-1,cardprofil-2);

 switch ( globalresult.type.ponaxis )
      {
      case EXTR_BOTH : return new OuvertOuvertOnAxisBoth(pas-1,cardprofil-1);
      case EXTR_SUP  : return new OuvertOuvertOnAxisSup(pas-1,cardprofil-1);
      case EXTR_INF  : return new OuvertOuvertOnAxisInf(pas-1,cardprofil-1);
      default        : return new OuvertOuvert(pas-1,cardprofil-1)   ;
      }
}


int ProfToProfAxisCAO::GenerateVertex( FILE* f ) {
  int         error;
  Sommet3D*   tbl;
  UINT        card;

  // on génère la forme.
  // -------------------
  if ( ( error = ModeleurProfToProf( profil,
                 profil1,
                 (UINT) cardprofil,
                 &tbl,
                 &card,
                 &(globalresult.type),
                  axis,
                  pas

      ) ) != SUCCESS ) return globalresult.error = error;

  // La boite limite.
  // ----------------
  BoiteLim  bl;
  SetBoiteLimite( tbl, card,&bl );

  // On sauve sur fichier.
  // ---------------------
  if ( fprintf ( f, "%f %f %f %f %f %f\n%u\n", bl.S1.x,
                     bl.S1.y,
                     bl.S1.z,
                     bl.S2.x,
                     bl.S2.y,
                     bl.S2.z,
                     card    ) == EOF )
          return globalresult.error =MOD_SOM_ERROR_BAD_FIC_WRITE;

  for ( UINT i = 0; i != card; i ++ )
      if ( fprintf ( f, "%lf %lf %lf\n", tbl[i].x,
                   tbl[i].y,
                   tbl[i].z   ) == EOF )
   return globalresult.error =MOD_SOM_ERROR_BAD_FIC_WRITE;

  fprintf ( f, "\n" );

  // on met à jour les renseignements.
  // ---------------------------------
  globalresult.cardsommet    = card;

  return SUCCESS; }


numerotation* ProfToProfAxisCAO::AllocNumerotation()
{
 if ( globalresult.type.pvert == VERT_CLOSE )
    return new OuvertFerme(pas-1,cardprofil-2);

 return new OuvertOuvert(pas-1,cardprofil-1);
}


int VecAxisCAO::GenerateVertex( FILE* f )
{ int           error;
  Sommet3D*   tbl;
  UINT            card;

  // on génère la forme.
  // -------------------
  if ( ( error = ModeleurVector    ( profil,
                  (UINT      ) cardprofil,
                 &tbl,
                 &card,
                 &(globalresult.type),
                  vectbl,
                  pas        )
    ) != SUCCESS )
     return globalresult.error =error;

  // La boite limite.
  // ----------------
  BoiteLim  bl;
  SetBoiteLimite( tbl, card,&bl );

  // On sauve sur fichier.
  // ---------------------
  if ( fprintf ( f, "%f %f %f %f %f %f\n%u\n", bl.S1.x,
                     bl.S1.y,
                     bl.S1.z,
                     bl.S2.x,
                     bl.S2.y,
                     bl.S2.z,
                     card    ) == EOF )
          return globalresult.error =MOD_SOM_ERROR_BAD_FIC_WRITE;

  for ( UINT i = 0; i != card; i ++ )
      if ( fprintf ( f, "%lf %lf %lf\n", tbl[i].x,
                   tbl[i].y,
                   tbl[i].z   ) == EOF )
   return globalresult.error =MOD_SOM_ERROR_BAD_FIC_WRITE;

  fprintf ( f, "\n" );

  // on met à jour les renseignements.
  // ---------------------------------
  globalresult.cardsommet    = card;

  return SUCCESS;
}


numerotation* VecAxisCAO::AllocNumerotation()
{
 if ( globalresult.type.pvert == VERT_CLOSE )
    return new OuvertFerme(pas-1,cardprofil-2);

 return new OuvertOuvert(pas-1,cardprofil-1);
}


int Generate ( AxisCAO& m )
{ int   error;
  char  ficname[15];


  FILE* f = fopen( strcat(strcpy(ficname,m.name),ShapeExt), "w" );
  if ( !f ) return MOD_GENERATE_ERROR_OPEN_FIC;

  if ( (error = m.GenerateVertex(f)) != SUCCESS )
     { fclose(f); return error; }

  if ( (error = m.GenerateArc(f)) != SUCCESS )
     { fclose(f); return error; }

  if ( (error = m.GenerateFace(f)) != SUCCESS )
     { fclose(f); return error; }

  fclose(f);

  return SUCCESS;
}

char* RotProfToProfAxisCAO::GetErrorMsg() {
 if ( globalresult.error >= __ReservedMsg)
     return  G_modetbmsg[ globalresult.error - __ReservedMsg ];
  return GetModelRotatErrorMsg( globalresult.error  );
}

char* ProfToProfAxisCAO::GetErrorMsg() {
 if ( globalresult.error >= __ReservedMsg)
     return  G_modetbmsg[ globalresult.error - __ReservedMsg ];
  return GetModelProfToProfErrorMsg( globalresult.error );
}

char* VecAxisCAO::GetErrorMsg() {
if ( globalresult.error >= __ReservedMsg)
     return  G_modetbmsg[ globalresult.error - __ReservedMsg ];
  return GetModelVectorErrorMsg( globalresult.error );
}

---