Texture.cpp

Go to the documentation of this file.

#include "../header/Texture.h"



Texture::Texture()
{
  picture = NULL;
  N_x=-1;
  N_y=-1;
}

Texture::~Texture()
{
  destroy();
}

int Texture::destroy()
{
  if(picture!=NULL)
    {
      delete[] picture;
      picture = NULL;
    }

  N_x=-1;
  N_y=-1;

  return 0;
}


int Texture::load_picture(const char* file_name)
{
  int ok=0;


  int file_type = get_file_type(file_name);
  ok+=destroy();

  switch(file_type)
    {
    case JPG_FORMAT:
      cout<<"JPG texture detected"<<endl;
      load_jpg_picture(file_name);
      cout<<"JPG texture loaded [OK]"<<endl;
      break;
    case PNG_FORMAT:
      cout<<"PNG texture detected"<<endl;
      load_png_picture(file_name);
      cout<<"PNG texture loaded [OK]"<<endl;
      break;
    case NO_FORMAT:
      cout<<"WARNING NO known format for "<<file_name<<endl;
    }


  return ok;
}


int Texture::load_jpg_picture(const char* file_name)
{
  int ok=0;

  struct jpeg_decompress_struct cinfo;
  struct jpeg_error_mgr jerr;
  FILE *file;   


  memset(&cinfo, 0, sizeof(cinfo));
  cinfo.err = jpeg_std_error(&jerr);

  if ((file=fopen(file_name,"rb"))==NULL)
    {
      fprintf(stderr,"Error : opening file %s\n",file_name);
      exit(1);
    }

  //read header
  jpeg_create_decompress(&cinfo);
  jpeg_stdio_src(&cinfo, file);
  jpeg_read_header(&cinfo, TRUE);
  jpeg_start_decompress(&cinfo);

  //size
  N_x = cinfo.image_width;
  N_y = cinfo.image_height;
  depth = cinfo.num_components;



  //  GLubyte *texels = new GLubyte[N_x*N_y*depth];
  //allocate
  picture = new unsigned char[N_x*N_y*depth];
  if(picture==NULL)
    {
      cout<<"ERROR allocating picture in jpg reader\n";
      exit(-1);
    }

  //process data
  JSAMPROW j;
  for (int k = 0; k < N_y; ++k)
    {
      j = (picture + (k * N_x * depth));
      jpeg_read_scanlines (&cinfo, &j, 1);
    }

  //end
  jpeg_finish_decompress(&cinfo);
  jpeg_destroy_decompress(&cinfo);


  return ok;
}



int Texture::load_png_picture(const char* file_name)
{
  //TOOK from David

  int             i;            /* Looping var */
  int             bpp;          /* Bytes per pixel */
  int             num_passes;   /* Number of interlace passes in file */
  int             pass;         /* Current pass in file */
  FILE           *fp;           /* File pointer */
  png_structp     pp;           /* PNG read pointer */
  png_infop       info;         /* PNG info pointers */
  unsigned char **pixels;       /* Pixel rows */

  pp = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
  info = png_create_info_struct (pp);

  if(!pp || !info)
    {
      printf("out of memory read png\n");
      exit(-1);
    }

  if (setjmp (pp->jmpbuf))
    {
      printf ("Error while reading '%s'. File corrupted?\n", file_name);
      return -1;
    }

  /* Open the file and initialize the PNG read "engine"...  */
  fp = fopen (file_name, "r");
  if (fp == NULL)
    {
      printf ("Could not open '%s' for reading: %s\n", file_name, strerror (errno));
      return -1;
    }
  png_init_io (pp, fp);
  png_read_info (pp, info);

  if (info->bit_depth == 16)
    png_set_strip_16 (pp);

  if (info->color_type == PNG_COLOR_TYPE_GRAY && info->bit_depth < 8)
    png_set_expand (pp);

  /* Expand G+tRNS to GA, RGB+tRNS to RGBA */

  if (info->valid & PNG_INFO_tRNS)
    png_set_expand (pp);

  /*
   * Turn on interlace handling... libpng returns just 1 (ie single pass)
   * if the image is not interlaced
   */

  num_passes = png_set_interlace_handling (pp);

  /* Update the info structures after the transformations take effect */
  png_read_update_info (pp, info);



  switch (info->color_type)
    {
    case PNG_COLOR_TYPE_RGB:           /* RGB */
      bpp = 3;
      break;

    case PNG_COLOR_TYPE_RGB_ALPHA:     /* RGBA */
      bpp = 4;
      break;

    case PNG_COLOR_TYPE_GRAY:          /* Grayscale */
      bpp = 1;
      break;

    case PNG_COLOR_TYPE_GRAY_ALPHA:    /* Grayscale + alpha */
      bpp = 2;
      break;

    default:                   /* Aie! Unknown type */
      printf ("Unknown color model in PNG file '%s'.\n", file_name);
      return -1;
    }

  N_x = info->width;
  N_y = info->height;

  picture = (unsigned char*)malloc(bpp*N_x*N_y*sizeof(unsigned char));
  //  picture = new unsigned char[bpp*N_x*N_y];


  /* png decodes by row... */
  pixels = (unsigned char**)malloc (sizeof (unsigned char *) * info->height);

  for (i = 0; i < N_y; i++)
    pixels[i] = picture + info->width * info->channels * i;

  for (pass = 0; pass < num_passes; pass++)
    png_read_rows (pp, pixels, NULL, N_y);

  png_read_end (pp, info);

  png_destroy_read_struct (&pp, &info, NULL);

  free (pixels);
  free (pp);
  free (info);
  

  fclose (fp);

  

  return 0;
}



int Texture::export_ppm(const char* _file_name)
{
  int ok=0;
  char file_name[100];


  
  FILE *fid_file;  
  
  //export in ppm

  if(picture==NULL)
    exit(-1);

  strcpy(file_name,_file_name);
  strcat(file_name,".ppm");

  fid_file = fopen(file_name,"w");
  if(fid_file==NULL)
    {
      cout<<"ERROR CANNOT CREATE "<<file_name<<"\n";
      return (-1);
    }

  fprintf(fid_file,"P3\n");//magic number
  fprintf(fid_file,"# %s.ppm\n",file_name);//name of the file in comment
  fprintf(fid_file,"%d %d\n",N_x,N_y);//size of the file
  fprintf(fid_file,"255\n");//max value

  int k;
  for(k=0;k<N_x*N_y;k++)
    fprintf(fid_file,"%d \n%d \n%d \n",picture[4*k],picture[4*k+1],picture[4*k+2]);

  ok+=fclose(fid_file);

  return ok;
}

int Texture::get_Nx()
{
  return N_x;
}
int Texture::get_Ny()
{
  return N_y;
}
int Texture::get_nearest_texel(float s_1,float s_2,float *texel)
{
  int ok=0;
  int us_1=0,us_2=0;
  int k_texture=0;
  int k_dim=0;

  if(picture==NULL)
    exit(-1);

  //nearest
  us_1 = (int)(fabs(s_1*N_x+0.5))%N_x;
  us_2 = (int)(fabs(s_2*N_y+0.5))%N_y;

  k_texture = 4*(us_1+us_2*N_x);


  for(k_dim=0;k_dim<3;k_dim++)
    {
      texel[k_dim] = (float)(picture[k_texture+k_dim])/256;
    }

  return ok;
}


int Texture::get_linear_texel(float s_1,float s_2,float *texel)
{
  int ok=0;

  float us_1=0.0,us_2=0.0;
  int k_1=0,k_2=0;

  us_1 = s_1*N_x;
  us_2 = s_2*N_y;

  k_1 = (int)us_1;
  k_2 = (int)us_2;

  //linear interpolant
  float t_x = (us_1-k_1);
  float t_y = (us_2-k_2);



  if(picture==NULL)
    {
      cout<<"ERROR NO PICTURE in texture interpolation\n";
      exit(-1);
    }

  int k_10=k_1,k_11=k_1+1;
  int k_20=k_2,k_21=k_2+1;

  //protection on boundaries
  if(k_11>=N_x)
    k_11=k_10;
  if(k_21>=N_y)
    k_21=k_20;

  int X00 = k_10 + k_20*N_x;
  int X01 = k_11 + k_20*N_x;
  int X10 = k_10 + k_21*N_x;
  int X11 = k_11 + k_21*N_x;


  int k_dim=0;

  for(k_dim=0;k_dim<3;k_dim++)
    {
      texel[k_dim] = 
            t_x *     t_y * (float)picture[4*X11+k_dim]+
        (1-t_x) *     t_y * (float)picture[4*X10+k_dim]+
            t_x * (1-t_y) * (float)picture[4*X01+k_dim]+
        (1-t_x) * (1-t_y) * (float)picture[4*X00+k_dim];
    }



  return ok;
}


unsigned char* Texture::get_data()
{
  return picture;
}


int Texture::get_file_type(const char* filename)
{
  int file_type = NO_FORMAT;
  char *buffer = NULL;

  //get last dot and return extension
  buffer = strrchr(filename,'.');

  if(strcmp(buffer+1,"jpg")==0 || strcmp(buffer+1,"jpeg")==0)
    file_type = JPG_FORMAT;
  if(strcmp(buffer+1,"png")==0)
    file_type = PNG_FORMAT;
  
  return file_type;
}

int Texture::get_depth()
{
  return depth;
}