cpolyhedron.c

Go to the documentation of this file.

#include "cpolyhedron.h"

#include "htransform.h"
#include "error.h"

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


void ReadOFF(FILE *f,Tcpolyhedron *p);

void GenerateCylinderOFF(unsigned int g,Tcpolyhedron *p);

void ReadCylinder(FILE *f,unsigned int g,Tcpolyhedron *p);

void GenerateSphereOFF(unsigned int g,Tcpolyhedron *p);

void ReadSphere(FILE *f,unsigned int g,Tcpolyhedron *p);

void ReadOFF(FILE *f,Tcpolyhedron *p)
{
  unsigned int i,j;
  double av;

  p->type=OFF;

  fscanf(f,"%u",&(p->nv));
  fscanf(f,"%u",&(p->nf));
  fscanf(f,"%u",&(p->ne));
  if ((p->nv==0)||(p->nf==0))
    Error("Empty OFF");

  NEW(p->v,p->nv,double*);
  for(i=0;i<p->nv;i++)
    {
      NEW(p->v[i],3,double);
      fscanf(f,"%lf",&(p->v[i][0]));
      fscanf(f,"%lf",&(p->v[i][1]));
      fscanf(f,"%lf",&(p->v[i][2]));
    }
  
  NEW(p->nvf,p->nf,unsigned int);
  NEW(p->fv,p->nf,unsigned int*);
  for(i=0;i<p->nf;i++)
    {
      fscanf(f,"%u",&(p->nvf[i]));
      if (p->nvf[i]==0)
        Error("Empty face in OFF");
      NEW(p->fv[i],p->nvf[i],unsigned int);

      for(j=0;j<p->nvf[i];j++)
        fscanf(f,"%u",&(p->fv[i][j]));
    }

  /* Cancel the sphere information */
  p->rad=0;
  p->center[0]=p->center[1]=p->center[2]=0.0;

  /* and the cylinder information too */
  p->p1[0]=p->p1[1]=p->p1[2]=0.0;
  p->p2[0]=p->p2[1]=p->p2[2]=0.0;

  /* Compute the bounding box */
  p->maxCoord=0;
  for(i=0;i<p->nv;i++)
    {
      for(j=0;j<3;j++)
        {
          av=fabs(p->v[i][j]);
          if (av>p->maxCoord)
            p->maxCoord=av;
        }
    }
}

void GenerateCylinderOFF(unsigned int g,Tcpolyhedron *p)
{
  unsigned int i,j,n;
  THTransform m;
  double a,av;

  if (p->type!=CYLINDER)
    Error("Using GenerateCylinderOFF in a non cylindric convex polyhedron");

  /*The points are defined on the reference cylinder (aligned along axis X
    and with length 1 and radii 1) that is later on scaled and enlarged */
  n=4+g;
  p->nv=2*n;
  NEW(p->v,p->nv,double*);
  for(i=0;i<n;i++)
    {
      NEW(p->v[i],3,double);
      NEW(p->v[n+i],3,double);

      p->v[i][0]=0;
      p->v[n+i][0]=1;

      a=(double)i/(double)n*M_2PI;
      p->v[i][1]=p->v[n+i][1]=cos(a);
      p->v[i][2]=p->v[n+i][2]=sin(a);
    }

  /*Now rotate the points according to the cylinder orientation defined by p1,p2*/
  HTransformX2Vect(p->rad,p->rad,p->p1,p->p2,&m);

  for(i=0;i<p->nv;i++)
    HTransformApply(p->v[i],p->v[i],&m);

  /*no face information*/
  p->nf=0;
  p->fv=NULL;
  p->nvf=NULL;

  HTransformDelete(&m);

  /* Compute the bounding box using the points that approximate the cylinder */
  p->maxCoord=0;
  for(i=0;i<p->nv;i++)
    {
      for(j=0;j<3;j++)
        {
          av=fabs(p->v[i][j]);
          if (av>p->maxCoord)
            p->maxCoord=av;
        }
    }
}

void ReadCylinder(FILE *f,unsigned int g,Tcpolyhedron *p)
{
  p->type=CYLINDER;

  fscanf(f,"%lf",&(p->rad));

  fscanf(f,"%lf",&(p->p1[0]));
  fscanf(f,"%lf",&(p->p1[1]));
  fscanf(f,"%lf",&(p->p1[2]));

  fscanf(f,"%lf",&(p->p2[0]));
  fscanf(f,"%lf",&(p->p2[1]));
  fscanf(f,"%lf",&(p->p2[2]));

  /*Cancel sphere information*/
  p->center[0]=p->center[1]=p->center[2]=0.0;

  /*Generate the OFF information*/
  GenerateCylinderOFF(g,p);
}

void GenerateSphereOFF(unsigned int g,Tcpolyhedron *p)
{
  unsigned int i,j,n,m;
  double **meridian;
  THTransform rz,tr;
  double a,offset,av;

  if (p->type!=SPHERE)
    Error("Using GenerateCylinderOFF in a non spheric convex polyhedron");

  /*Vertex information for collision avoidance (in the future refined according to 'g')*/
  n=1+g;
  m=4+g;

  offset=M_PI_2/((double)(n+1));
  a=0.0;

  NEW(meridian,2*n,double*);
  for(i=0;i<n;i++)
    {
      a+=offset;
      NEW(meridian[i],3,double);
      meridian[i][0]=p->rad*cos(a);
      meridian[i][1]=0.0;
      meridian[i][2]=p->rad*sin(a);

      NEW(meridian[n+i],3,double); 
      meridian[n+i][0]=meridian[i][0];
      meridian[n+i][1]=0.0;
      meridian[n+i][2]=-meridian[i][2];
    }

  p->nv=2*n*m;
  NEW(p->v,p->nv,double*);
  for(i=0;i<p->nv;i++)
    NEW(p->v[i],3,double);

  a=0.0;
  offset=M_2PI/(double)m;

  for(j=0;j<m;j++)
    {
      HTransformTxyz(p->center[0],p->center[1],p->center[2],&tr);
      HTransformRz(a,&rz);
      HTransformProduct(&tr,&rz,&tr);
      for(i=0;i<2*n;i++)
        HTransformApply(meridian[i],p->v[j*(2*n)+i],&tr);

      a+=offset;
      
      HTransformDelete(&tr);
      HTransformDelete(&rz);
    }
  
  for(i=0;i<2*n;i++)
    free(meridian[i]);
  free(meridian);

  /*no face information*/
  p->nf=0;
  p->fv=NULL;
  p->nvf=NULL;

  /* Compute the bounding box using the points that approximate the sphere */
  p->maxCoord=0;
  for(i=0;i<p->nv;i++)
    {
      for(j=0;j<3;j++)
        {
          av=fabs(p->v[i][j]);
          if (av>p->maxCoord)
            p->maxCoord=av;
        }
    }
}

void ReadSphere(FILE *f,unsigned int g,Tcpolyhedron *p)
{
  p->type=SPHERE;

  fscanf(f,"%lf",&(p->rad));

  fscanf(f,"%lf",&(p->center[0]));
  fscanf(f,"%lf",&(p->center[1]));
  fscanf(f,"%lf",&(p->center[2]));

  /*Cancel cylinder information*/
  p->p1[0]=p->p1[1]=p->p1[2]=0.0;
  p->p2[0]=p->p2[1]=p->p2[2]=0.0;

  /*Generate the OFF information*/
  GenerateSphereOFF(g,p);
}

void InitCPolyhedronFromFile(char *fname,Tcolor *c,
                             unsigned int gr,Tcpolyhedron *p)
{
  FILE *f;
  char *stmp; 
  boolean off, cylinder,sphere;

  CopyColor(&(p->color),c);
  
  p->obj3d=NO_UINT;

  NEW(stmp,20,char); /* 20 is enough to read OFF/SPHERE/CYLINDER */

  f=fopen(fname,"r");
  if (!f)
    Error("Could not open CPolyhedron file");

  fscanf(f,"%s",stmp); /* OFF -> skip it */

  off=(strcmp(stmp,"OFF")==0);
  cylinder=(strcmp(stmp,"CYLINDER")==0);
  sphere=(strcmp(stmp,"SPHERE")==0);

  if ((!off)&&(!cylinder)&&(!sphere))
    Error("Unknow type of shape");

  if (off)
    ReadOFF(f,p);
  
  if (cylinder)
    ReadCylinder(f,gr,p);

  if (sphere)
    ReadSphere(f,gr,p);

  free(stmp);
  fclose(f);
}

void NewSphere(double r,double *center,Tcolor *c,
               unsigned int gr,Tcpolyhedron *p)
{
  p->type=SPHERE;

  CopyColor(&(p->color),c);
  p->obj3d=NO_UINT;

  /*Set the sphere information*/
  p->rad=r;

  p->center[0]=center[0];
  p->center[1]=center[1];
  p->center[2]=center[2];

  /*Cancel cylinder information*/
  p->p1[0]=p->p1[1]=p->p1[2]=0.0;
  p->p2[0]=p->p2[1]=p->p2[2]=0.0;

  /*Generate the OFF information*/
  GenerateSphereOFF(gr,p);
}

void NewCylinder(double r,double *p1,double *p2,Tcolor *c,
                 unsigned int gr,Tcpolyhedron *p)
{
  p->type=CYLINDER;

  CopyColor(&(p->color),c);
  p->obj3d=NO_UINT;

  /*Set the cylinder information*/
  p->rad=r;

  p->p1[0]=p1[0];
  p->p1[1]=p1[1];
  p->p1[2]=p1[2];

  p->p2[0]=p2[0];
  p->p2[1]=p2[1];
  p->p2[2]=p2[2];

  /*Cancel sphere information*/
  p->center[0]=p->center[1]=p->center[2]=0.0;

  /*Generate the OFF information*/
  GenerateCylinderOFF(gr,p);
}


void CopyCPolyhedron(Tcpolyhedron *p_dst,Tcpolyhedron *p_src)
{
  unsigned int i,j;

  p_dst->type=p_src->type;

  /*plot3d information*/
  CopyColor(&(p_dst->color),&(p_src->color));
 
  p_dst->obj3d=p_src->obj3d;

  /* off information */
  p_dst->nv=p_src->nv;
  p_dst->nf=p_src->nf;
  p_dst->ne=p_src->ne;

  NEW(p_dst->v,p_src->nv,double*);
  for(i=0;i<p_dst->nv;i++)
    {
      NEW(p_dst->v[i],3,double);
      p_dst->v[i][0]=p_src->v[i][0];
      p_dst->v[i][1]=p_src->v[i][1];
      p_dst->v[i][2]=p_src->v[i][2];
    }

  NEW(p_dst->nvf,p_dst->nf,unsigned int);
  NEW(p_dst->fv,p_dst->nf,unsigned int*);
  for(i=0;i<p_dst->nf;i++)
    {
      p_dst->nvf[i]=p_src->nvf[i];
      NEW(p_dst->fv[i],p_dst->nvf[i],unsigned int);

      for(j=0;j<p_dst->nvf[i];j++)
        p_dst->fv[i][j]=p_src->fv[i][j];
    }

  /*Sphere - Cylinder information*/
  p_dst->rad=p_src->rad;
  for(i=0;i<3;i++)
    {
      p_dst->center[i]=p_src->center[i];
      p_dst->p1[i]=p_src->p1[i];
      p_dst->p2[i]=p_src->p2[i];
    }

  p_dst->maxCoord=p_src->maxCoord;
}

void TransformCPolyhedron(THTransform *t,Tcpolyhedron *p)
{
  unsigned int i,j;
  double av;

  /*Off information*/
  p->maxCoord=0;
  for(i=0;i<p->nv;i++)
    {
      HTransformApply(p->v[i],p->v[i],t);
      for(j=0;j<3;j++)
        {
          av=fabs(p->v[i][j]);
          if (av>p->maxCoord)
            p->maxCoord=av;
        }
    }

  /*Sphere - Cylinder information*/
  HTransformApply(p->center,p->center,t);
  HTransformApply(p->p1,p->p1,t);
  HTransformApply(p->p2,p->p2,t);
}

unsigned int GetCPolyhedronType(Tcpolyhedron *p)
{
  return(p->type);
}

void SetCPolyhedronColor(Tcolor *c,Tcpolyhedron *p)
{
  CopyColor(&(p->color),c);
}

void GetCPolyhedronColor(Tcolor *c,Tcpolyhedron *p)
{
  CopyColor(c,&(p->color));
}

unsigned int GetCPolyhedronNVertex(Tcpolyhedron *p)
{
  return(p->nv);
}

void GetCPolyhedronDefiningPoint(unsigned int i,double *point,Tcpolyhedron *p)
{
  unsigned int j;

  switch(p->type)
    {
    case CYLINDER:
      if (i>1)
        Error("Vertex counter out of range in GetCPolyhedronInterestPoint");
      
      if (i==0)
        {
          for(j=0;j<3;j++)
            point[j]=p->p1[j];
        }
      else
        {
          for(j=0;j<3;j++)
            point[j]=p->p2[j];
        }
      break;

    case SPHERE:
      if (i>0)
        Error("Vertex counter out of range in GetCPolyhedronInterestPoint");
      
      for(j=0;j<3;j++)
        point[j]=p->center[j];
      break;

    case OFF:
      GetCPolyhedronVertex(i,point,p);
      break;

    default:
      Error("Undefined CPolyhedron type in GetCPolyhedronInterestPoint");
      break;
    }
}

double GetCpolyhedronRadius(Tcpolyhedron *p)
{
  if (p->type==OFF)
    Error("Radius is not defined for OFFs");
  return(p->rad);
}

void GetCPolyhedronVertex(unsigned int i,double *point,Tcpolyhedron *p)
{
  unsigned int j;

  if (i>=p->nv)
    Error("Vertex counter out of range");

  for(j=0;j<3;j++)
    point[j]=p->v[i][j];
}

double GetCPolyhedronMaxCoordinate(Tcpolyhedron *p)
{
  return(p->maxCoord);
}

void PlotCPolyhedron(Tplot3d *pt,Tcpolyhedron *p)
{
  p->obj3d=StartNew3dObject(&(p->color),pt);

  switch(p->type)
    {
    case OFF:
      Plot3dObject(p->nv,p->nf,p->ne,p->v,p->nvf,p->fv,pt);                                     
      break;
    case CYLINDER:
      PlotCylinder(p->rad,p->p1,p->p2,pt);
      /*
        {
        unsigned int i;

        for(i=0;i<p->nv;i++)
        PlotSphere(0.015,p->v[i][0],p->v[i][1],p->v[i][2],pt);
        }
      */
      break;
    case SPHERE:
      PlotSphere(p->rad,p->center[0],p->center[1],p->center[2],pt);
      /*
        {
        unsigned int i;

        for(i=0;i<p->nv;i++)
        PlotSphere(0.015,p->v[i][0],p->v[i][1],p->v[i][2],pt);
        }
      */
      break;
    }
  
  Close3dObject(pt);
}

void MoveCPolyhedron(Tplot3d *pt,THTransform *t,Tcpolyhedron *p)
{
  if (p->obj3d!=NO_UINT)
    Move3dObject(p->obj3d,t,pt);
}

void SaveCPolyhedron(char *fileName,Tcpolyhedron *p)
{
  FILE *f;
  unsigned int i,j;
  
  f=fopen(fileName,"w");
  if (!f)
    Error("Could not open output file for a convex polyhedron");

  switch(p->type)
    {
    case OFF:
      fprintf(f,"OFF\n");
      fprintf(f,"%u %u 1\n\n",p->nv,p->nf);
      for(i=0;i<p->nv;i++)
        fprintf(f,"%f %f %f\n",p->v[i][0],p->v[i][1],p->v[i][2]);
      fprintf(f,"\n");
      for(i=0;i<p->nf;i++)
        {
          fprintf(f,"%u ",p->nvf[i]);
          for(j=0;j<p->nvf[i];j++)
            fprintf(f," %u",p->fv[i][j]);
          fprintf(f,"\n");
        }
      break;
    case CYLINDER:
      fprintf(f,"CYLINDER\n");
      fprintf(f,"%f\n",p->rad);
      fprintf(f,"%f %f %f\n",p->p1[0],p->p1[1],p->p1[2]);
      fprintf(f,"%f %f %f\n",p->p2[0],p->p2[1],p->p2[2]);
      break;
    case SPHERE:
      fprintf(f,"SPHERE\n");
      fprintf(f,"%f\n",p->rad);
      fprintf(f,"%f %f %f\n",p->center[0],p->center[1],p->center[2]);
      break;
    }

  fclose(f);
}

void DeleteCPolyhedron(Tcpolyhedron *p)
{
  unsigned int i;

  for(i=0;i<p->nv;i++)
    free(p->v[i]);
  free(p->v);

  if (p->nf>0)
    {
      for(i=0;i<p->nf;i++)
        free(p->fv[i]);
      
      free(p->fv);
      free(p->nvf);
    }
}