ellipse.c

Go to the documentation of this file.

/*****************************************************************************/
int ELLIPSE_TEST;
int ELLIPSE_VERBOSE;
/*****************************************************************************/
#include "libtpcrec.h"
/*****************************************************************************/
 
/*****************************************************************************/
/* Initialization and memory handling for ellipse data.*/
/*****************************************************************************/
void ellipseInit(ELLIPSE *ell)
{
  if(ELLIPSE_VERBOSE) printf("ELLIPSE: ellipseInit(). \n");
 
  /*Init the information on ellipse.*/
  //buffer ell to contain zero
  memset(ell, 0, sizeof(ELLIPSE)); 
  ell->status=ELLIPSE_STATUS_INITIALIZED;
  ell->semiaxis[0]=ell->semiaxis[1]=0.;
  ell->center[0]=ell->center[1]=0.;
  ell->inclination=0.;
  ell->imageDim=0;
  ell->value=0;
 
  /*Init the ellipse array*/
  ell->ellipseptr=(int**)NULL;
}
/*****************************************************************************/
void ellipseEmpty(ELLIPSE *ell)
{
 if(ELLIPSE_VERBOSE) printf("ELLIPSE: ellipseEmpty(). \n");
 
  //if ell is already empty
  if(ell->status<ELLIPSE_STATUS_OCCUPIED) return;
 
  //free the memory occupied by ellipse array
  free(ell->ellipseptr);
 
  //Init the information again
  ell->semiaxis[0]=ell->semiaxis[1]=0.;
  ell->center[0]=ell->center[1]=0.;
  ell->inclination=0.;
  ell->imageDim=0;
  ell->value=0;
  /*Init the ellipse array*/
  ell->ellipseptr=(int**)NULL;
 
  ell->status=ELLIPSE_STATUS_INITIALIZED;
}
/*****************************************************************************/
void ellipseInfo(ELLIPSE *ell)
{
  printf("ellipseInfo()\n");
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED){
    printf("Ellipse data not initialized.\n"); return;
  }
  printf("Semiaxis: (%.5f,%.5f)\n",ell->semiaxis[0], ell->semiaxis[1]);
  printf("Center: (%.2f,%.2f)\n",ell->center[0],ell->center[1]);
  printf("Inclination (degrees): %f\n",ell->inclination);
  printf("Image dimension: %i\n",ell->imageDim);
  printf("Value: %f\n",ell->value);
}
/*****************************************************************************/
int ellipseAllocate(ELLIPSE *ell, int imgDim)
{
  int i;
  if(ELLIPSE_VERBOSE) printf("ELLIPSE:ellipseAllocate(*ell,%i) \n",imgDim);
  
  /*check the arguments*/
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return(1);
  if(imgDim<1 || imgDim>4096) return(2);
  
  //allocate memory
  ell->ellipseptr=(int**)calloc(imgDim,sizeof(int*));
  for(i=0;i<imgDim;i++){
    ell->ellipseptr[i]=(int*)calloc(imgDim,sizeof(int));
  }
  return(0);
}
/*****************************************************************************/
/* GET and SET procedures for ELLIPSE datatype. 
 * USE ONLY THESE FOR SETTING AND GETTING. */
/*****************************************************************************/
int ellipseSetFromParams(
  ELLIPSE *ell,
  int imgDim,
  float *semis,
  float *cent,
  float incli,
  float val
) {
  float    d, x, y, inclination;
  int      row, col;
 
  /*check the arguments*/
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return(1);
  if(imgDim<1 || imgDim>4096) return(2);
  if(0>semis[0] || 0>semis[1]) return(3);
  if(-(float)imgDim/2.>cent[0] || (float)imgDim/2.<cent[0]) return(4);
  if(-(float)imgDim/2.>cent[1] || (float)imgDim/2.<cent[1]) return(5);
 
  //allocate memory for ellipse
  ellipseAllocate(ell,imgDim);
 
  //set the information on ellipse
  ell->semiaxis[0]=semis[0];
  ell->semiaxis[1]=semis[1];
  ell->center[0]=cent[0];
  ell->center[1]=cent[1];
  ell->inclination=incli;
  ell->imageDim=imgDim;
  ell->value=val;
 
  //set inclination ratio for setting inclination approximately
  inclination= -(float)(incli/90.);
 
  //set ellipse array according to given arguments
  for(row=0; row<imgDim; row++) {
   for(col=0; col<imgDim; col++) {
     // the y-coordinate of row in coordinates where origin is set in the middle
     y=(float)imgDim*0.5 - (float)row - cent[1]; 
     /* the x-coordinate of column in coordinates where origin is set in 
        the middle and inclination is added */
     x=(float)col - (float)imgDim*0.5 - (cent[0] + inclination*y); 
     d=(x*x)/(semis[0]*semis[0]) + (y*y)/(semis[1]*semis[1]); 
       //if this pixel is inside the ellipse
       if(d<1.0) { 
         //put 1 in place (row,col)
   ell->ellipseptr[row][col]=1;
       }
   }//END OF COL-LOOP 
  }//END OF ROW-LOOP
  return(0);
}
/*****************************************************************************/
int ellipseReadEllipse(
  FILE *fp, 
  ELLIPSE *ell 
) {
  float v, incli, semiaxis[2], center[2], imgDim;
  int ret=0;
 
  if(ELLIPSE_VERBOSE) printf("ellipseReadEllipse() \n");
 
  if(fread(&v,sizeof(float),1,fp)==0) {fclose(fp); return(2);}
  if(fread(&semiaxis[0],sizeof(float),1,fp)==0) {fclose(fp); return(2);}
  if(fread(&semiaxis[1],sizeof(float),1,fp)==0) {fclose(fp); return(2);}
  if(fread(&center[0],sizeof(float),1,fp)==0) {fclose(fp); return(2);}
  if(fread(&center[1],sizeof(float),1,fp)==0) {fclose(fp); return(2);}
  if(fread(&incli,sizeof(float),1,fp)==0) {fclose(fp); return(2);}
  if(fread(&imgDim,sizeof(float),1,fp)==0) {fclose(fp); return(2);}
 
  if(feof(fp)) return 1;
 
  //create the ellipse
  ret=ellipseSetFromParams(ell, imgDim, semiaxis, center, incli,v);
  if(ret){ ellipseEmpty(ell); return ret;}
  return 0;
}
/*****************************************************************************/
int ellipseSaveEllipse(
  ELLIPSE *ell,
  FILE *fp
) {
  if(ELLIPSE_VERBOSE) printf("ellipseSaveEllipse()\n");
 
  // Put ellipse in the file.
  fwrite(&(ell->value),sizeof(float),1,fp);
  fwrite(&(ell->semiaxis[0]),sizeof(float),1,fp);
  fwrite(&(ell->semiaxis[1]),sizeof(float),1,fp);
  fwrite(&(ell->center[0]),sizeof(float),1,fp);
  fwrite(&(ell->center[1]),sizeof(float),1,fp);
  fwrite(&(ell->inclination),sizeof(float),1,fp);
  fwrite(&(ell->imageDim),sizeof(float),1,fp);
 
  return(0);
}
/*****************************************************************************/
float ellipseGetMajor(ELLIPSE *ell)
{
  if(ELLIPSE_VERBOSE) printf("ELLIPSE:ellipseGetMajor(). \n");
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return(-1);
  return(ell->semiaxis[0]);
}
/*****************************************************************************/
float ellipseGetMinor(ELLIPSE *ell)
{
  if(ELLIPSE_VERBOSE) printf("ELLIPSE:ellipseGetMinor(). \n");
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return(-1);
  return(ell->semiaxis[1]);
}
/*****************************************************************************/
float ellipseGetCenterX(ELLIPSE *ell)
{
  if(ELLIPSE_VERBOSE) printf("ELLIPSE:ellipseGetCenterX(). \n");
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return(-1);
  return(ell->center[0]);
}
/*****************************************************************************/
float ellipseGetCenterY(ELLIPSE *ell)
{
  if(ELLIPSE_VERBOSE) printf("ELLIPSE:ellipseGetCenterY(). \n");
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return(-1);
  return(ell->center[1]);
}
/*****************************************************************************/
float ellipseGetInclination(ELLIPSE *ell)
{
  if(ELLIPSE_VERBOSE) printf("ELLIPSE:ellipseGetInclination(). \n");
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return(-1);
  return(ell->inclination);
}
/*****************************************************************************/
int ellipseGetImgSize(ELLIPSE *ell)
{
  if(ELLIPSE_VERBOSE) printf("ELLIPSE:ellipseGetImgSize(). \n");
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return(-1);
  return(ell->imageDim);
}
/*****************************************************************************/
int ellipseGetValue(ELLIPSE *ell)
{
  if(ELLIPSE_VERBOSE) printf("ELLIPSE:ellipseGetValue(). \n");
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return(-1);
  return(ell->value);
}
/*****************************************************************************/
int **ellipseGetArray(ELLIPSE *ell)
{
  if(ELLIPSE_VERBOSE) printf("ELLIPSE:ellipseGetArray(). \n");
  if(ell->status==ELLIPSE_STATUS_UNINITIALIZED) return((int**)-1);
  return(ell->ellipseptr);
}
/*****************************************************************************/
/* Testing procedures for ellipse. */
/*****************************************************************************/
int ellipseIsInside(
  ELLIPSE *ell, 
  int row, 
  int col
) {
  //no checking on parameters to accelerate use inside a loop
  return(ell->ellipseptr[row][col]);
}
/*****************************************************************************/
 
/*****************************************************************************/