tools::png Namespace Reference

Classes
class	reader

Functions
bool	is (const std::string &a_file)
unsigned char *	read_FILE (FILE *a_file, unsigned int &a_width, unsigned int &a_height, unsigned int &a_bpp)
unsigned char *	read (std::ostream &a_out, const std::string &a_file, unsigned int &a_width, unsigned int &a_height, unsigned int &a_bpp)
unsigned char *	read_part (std::ostream &a_out, const std::string &a_file, unsigned int a_sx, unsigned int a_sy, unsigned int a_sw, unsigned int a_sh, unsigned int &a_rw, unsigned int &a_rh, unsigned int &a_rbpp)
bool	write_FILE (FILE *a_file, unsigned char *a_buffer, unsigned int a_width, unsigned int a_height, unsigned int a_bpp)
bool	write (std::ostream &a_out, const std::string &a_file, unsigned char *a_buffer, unsigned int a_width, unsigned int a_height, unsigned int a_bpp)
bool	infos_FILE (FILE *a_file, unsigned int &a_width, unsigned int &a_height, unsigned int &a_bpp)
bool	infos (std::ostream &a_out, const std::string &a_file, unsigned int &a_width, unsigned int &a_height, unsigned int &a_bpp)
bool	to_xpm (std::ostream &a_out, const std::string &a_file, const std::string &a_name, bool a_verbose=false)
bool	concatenate (std::ostream &a_out, const std::vector< std::string > &a_files, unsigned int a_cols, unsigned int a_rows, unsigned int a_bw, unsigned int a_bh, unsigned char a_bc, const std::string &a_file)

Function Documentation

concatenate()

bool tools::png::concatenate ( std::ostream &  a_out, const std::vector< std::string > &  a_files, unsigned int  a_cols, unsigned int  a_rows, unsigned int  a_bw, unsigned int  a_bh, unsigned char  a_bc, const std::string &  a_file  )

inline

Definition at line 426 of file png.

                                                 {
  unsigned int wa,ha,bppa;
  unsigned char* ba =
    tools::image::concatenate
      (a_out,a_files,a_cols,a_rows,a_bw,a_bh,a_bc,read,wa,ha,bppa);
  if(!ba) {
    a_out << "tools::png::concatenate :"
          << " failed to concatenate all buffers."
          << std::endl;
    delete [] ba;
    return false;
  }
 
  FILE* file = ::fopen(a_file.c_str(),"wb");
  if(!file) {
    a_out << "tools::png::concatenate :"
          << " can't open " << file << " for writing."
          << std::endl;
    delete [] ba;
    return false;
  }
 
  if(!write_FILE(file,ba,wa,ha,bppa)) {
    a_out << "tools::png::concatenate :"
          << " can't write " << a_file << "."
          << std::endl;
    delete [] ba;
    ::fclose(file);
    return false;
  }
 
  delete [] ba;
  ::fclose(file);
  return true;
}

infos()

bool tools::png::infos ( std::ostream &  a_out, const std::string &  a_file, unsigned int &  a_width, unsigned int &  a_height, unsigned int &  a_bpp  )

inline

Definition at line 364 of file png.

                                                                                                                              {
  if(!is(a_file)) {
    a_out << "tools::png::infos :"
          << " file " << a_file << " is not png."
          << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  FILE* file = ::fopen(a_file.c_str(),"rb");
  if(!file) {
    a_out << "tools::png::infos :"
          << " can't open " << a_file
          << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  unsigned int w,h,bpp;
  bool status = infos_FILE(file,w,h,bpp);
 
  ::fclose(file);
 
  if(!status) {
    a_out << "tools::png::infos :"
              << " problem reading " << a_file
              << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  a_width = w;
  a_height = h;
  a_bpp = bpp;
  return true;
}

infos_FILE()

bool tools::png::infos_FILE ( FILE *  a_file, unsigned int &  a_width, unsigned int &  a_height, unsigned int &  a_bpp  )

inline

Definition at line 307 of file png.

                                                                                                      {
  //a_bpp = number of bytes per pixel.
  png_byte header[8];   // 8 is the maximum size that can be checked
  if(::fread(header,1,8,a_file)!=8) {
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
  if(::png_sig_cmp(header,0,8)) {
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  png_structp png_ptr =
    ::png_create_read_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL);
  if(!png_ptr) {
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  png_infop info_ptr = ::png_create_info_struct(png_ptr);
  if(!info_ptr) {
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  if(::setjmp(png_jmpbuf(png_ptr))) {
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  ::png_init_io(png_ptr,a_file);
  ::png_set_sig_bytes(png_ptr,8);
  ::png_read_info(png_ptr,info_ptr);
 
  png_uint_32 width = ::png_get_image_width(png_ptr,info_ptr);
  png_uint_32 height = ::png_get_image_height(png_ptr,info_ptr);
  png_uint_32 rowbytes = ::png_get_rowbytes(png_ptr,info_ptr);
  a_bpp = width?rowbytes/width:0;
  
  ::png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
 
  a_width = width;
  a_height = height;
 
  return true;
}

is()

bool tools::png::is ( const std::string &  a_file )

inline

Definition at line 23 of file png.

                                       {
  FILE* file = ::fopen(a_file.c_str(),"rb");
  if(!file) return false; //if file does not exist, then it is not a png !
  png_byte header[8];   // 8 is the maximum size that can be checked
  size_t nitem = ::fread(header,1,8,file);
  ::fclose(file);
  if(nitem!=8) return false;
  return ::png_sig_cmp(header,0,8)?false:true;
}

read()

unsigned char* tools::png::read ( std::ostream &  a_out, const std::string &  a_file, unsigned int &  a_width, unsigned int &  a_height, unsigned int &  a_bpp  )

inline

Definition at line 145 of file png.

                                                                                                                                       {
  //a_bpp = number of bytes per pixel.
  FILE* file = fopen(a_file.c_str(),"rb");
  if(!file) {
    a_out << "tools::png::read :"
          << " can't open file " << tools::sout(a_file) << "."
          << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
  unsigned char* buffer = read_FILE(file,a_width,a_height,a_bpp);
  if(!buffer) {
    ::fclose(file);
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    a_out << "tools::png::read :"
          << " read_FILE " << tools::sout(a_file) << " failed."
          << std::endl;
    return 0;
  }
  ::fclose(file);
  return buffer;
}

read_FILE()

unsigned char* tools::png::read_FILE ( FILE *  a_file, unsigned int &  a_width, unsigned int &  a_height, unsigned int &  a_bpp  )

inline

Definition at line 40 of file png.

                                                                                                               {
 
  png_byte header[8];   // 8 is the maximum size that can be checked
  if(::fread(header,1,8,a_file)!=8) {
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
  if(::png_sig_cmp(header,0,8)) {
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  png_structp png_ptr =
    ::png_create_read_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL);
  if(!png_ptr) {
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  png_infop info_ptr = ::png_create_info_struct(png_ptr);
  if(!info_ptr) {
    ::png_destroy_read_struct(&png_ptr,NULL,NULL);
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  if(::setjmp(png_jmpbuf(png_ptr))) {
    ::png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  ::png_init_io(png_ptr,a_file);
  ::png_set_sig_bytes(png_ptr,8);
 
  ::png_read_info(png_ptr,info_ptr);
 
  png_uint_32 width = ::png_get_image_width(png_ptr,info_ptr);
  png_uint_32 height = ::png_get_image_height(png_ptr,info_ptr);
  png_uint_32 rowbytes = ::png_get_rowbytes(png_ptr,info_ptr);
  int bpp = width?rowbytes/width:0;
 
  if((width<=0)||(height<=0)||(bpp<=0)) {
    ::png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  a_bpp = bpp; //avoid the clobbered -W warning.
 
  //png_byte color_type = info_ptr->color_type;
  //info_ptr->bit_depth;
 
  //int number_of_passes = ::png_set_interlace_handling(png_ptr);
  ::png_read_update_info(png_ptr,info_ptr);
 
  if(::setjmp(png_jmpbuf(png_ptr))) {
    ::png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  unsigned char* buffer = new unsigned char[rowbytes * height];
  if(!buffer) {
    ::png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
    a_height = 0;
    a_width = 0;
    a_bpp = 0;
    return 0;
  }
 
 {png_bytep* row_pointers = new png_bytep[height];
  png_byte* pos = buffer+rowbytes*(height-1);
  for(png_uint_32 y=0;y<height;y++) {
    row_pointers[y] = pos;
    pos -= rowbytes;
  }
  ::png_read_image(png_ptr,row_pointers);
  delete [] row_pointers;}
 
  ::png_read_end(png_ptr,info_ptr);
 
  ::png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
 
  a_width = width;
  a_height = height;
  //a_bpp = bpp; //avoid the clobbered -W warning.
 
  return buffer;
}

read_part()

unsigned char* tools::png::read_part ( std::ostream &  a_out, const std::string &  a_file, unsigned int  a_sx, unsigned int  a_sy, unsigned int  a_sw, unsigned int  a_sh, unsigned int &  a_rw, unsigned int &  a_rh, unsigned int &  a_rbpp  )

inline

Definition at line 172 of file png.

                                                      {
  a_out << "tools::png::read_part :"
        << " not yet implemented."
        << std::endl;
  a_rw = 0;
  a_rh = 0;
  a_rbpp = 0;
  return 0;
 
  unsigned int w,h,bpp;
  unsigned char* buffer = read(a_out,a_file,w,h,bpp);
  if(!buffer){
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  if((a_sx>=w)||(a_sy>=h)){
    delete [] buffer;
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  // 012345
  a_rw = tools::mn<unsigned int>(w-a_sx,a_sw);
  a_rh = tools::mn<unsigned int>(h-a_sy,a_sh);
  a_rbpp = bpp;
 
  if(!a_rw||!a_rh||!a_rbpp){
    delete [] buffer;
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  unsigned char* rb = new unsigned char[a_rw*a_rh*a_rbpp];
  if(!rb) {
    delete [] buffer;
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  unsigned int rstride = a_rw * a_rbpp;
  unsigned char* rpos = rb;
 
  unsigned int stride = w * bpp;
  unsigned char* pos = buffer+a_sy*stride+a_sx*bpp;
 
  for(unsigned int j=0;j<a_rh;j++,rpos+=rstride,pos+=stride) {//j=0 -> bottom.
    ::memcpy(rpos,pos,rstride);
  }
 
  delete [] buffer;
 
  return rb;
}

to_xpm()

bool tools::png::to_xpm ( std::ostream &  a_out, const std::string &  a_file, const std::string &  a_name, bool  a_verbose = false  )

inline

Definition at line 414 of file png.

                                                                                                             {
  return tools::xpm::to_xpm(a_out,a_file,a_name,read,a_verbose);
}

write()

bool tools::png::write ( std::ostream &  a_out, const std::string &  a_file, unsigned char *  a_buffer, unsigned int  a_width, unsigned int  a_height, unsigned int  a_bpp  )

inline

Definition at line 283 of file png.

                                      {
  FILE* file = ::fopen(a_file.c_str(),"wb");
  if(!file) {
    a_out << "tools::png::write :"
          << " can't open file " << tools::sout(a_file) << "."
          << std::endl;
    return false;
  }
  if(!write_FILE(file,a_buffer,a_width,a_height,a_bpp)) {
    ::fclose(file);
    a_out << "tools::png::write :"
          << " can't write file " << tools::sout(a_file) << "."
          << std::endl;
    return false;
  }
  ::fclose(file);
  return true;
}

write_FILE()

bool tools::png::write_FILE ( FILE *  a_file, unsigned char *  a_buffer, unsigned int  a_width, unsigned int  a_height, unsigned int  a_bpp  )

inline

Definition at line 240 of file png.

                                                                                                                           {
  //from gl2ps.c.
  if((a_bpp!=3)&&(a_bpp!=4)) {
    return false;
  }
 
  png_structp png_ptr;
  if(!(png_ptr = ::png_create_write_struct
                    (PNG_LIBPNG_VER_STRING,NULL,NULL,NULL))) return false;
 
  png_infop info_ptr;
  if(!(info_ptr = ::png_create_info_struct(png_ptr))){
    ::png_destroy_write_struct(&png_ptr,NULL);
    return false;
  }
 
  if(::setjmp(png_jmpbuf(png_ptr))) {
    ::png_destroy_write_struct(&png_ptr,&info_ptr);
    return false;
  }
 
#ifndef Z_DEFAULT_COMPRESSION
#define Z_DEFAULT_COMPRESSION  (-1)
#endif
 
  ::png_init_io(png_ptr,a_file);
  ::png_set_compression_level(png_ptr,Z_DEFAULT_COMPRESSION);
  ::png_set_IHDR(png_ptr,info_ptr,a_width,a_height,8,
                 a_bpp==3?PNG_COLOR_TYPE_RGB:PNG_COLOR_TYPE_RGBA,
                 PNG_INTERLACE_NONE,
                 PNG_COMPRESSION_TYPE_BASE,PNG_FILTER_TYPE_BASE);
  ::png_write_info(png_ptr,info_ptr);
 
  for(unsigned int row=0;row<a_height;row++){
    unsigned char* pos = a_buffer+(a_height-1-row)*(a_width*a_bpp);
    ::png_write_row(png_ptr,(png_bytep)pos);
  }
 
  ::png_write_end(png_ptr,info_ptr);
  ::png_destroy_write_struct(&png_ptr,&info_ptr);
  return true;
}