igl::png Namespace Reference

Functions
IGL_INLINE bool	readPNG (const std::string png_file, Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &R, Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &G, Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &B, Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &A)
IGL_INLINE bool	render_to_png (const std::string png_file, const int width, const int height, const bool alpha=true, const bool fast=false)
IGL_INLINE std::thread	render_to_png_async (const std::string png_file, const int width, const int height, const bool alpha=true, const bool fast=false)
IGL_INLINE bool	texture_from_file (const std::string filename, GLuint &id)
IGL_INLINE bool	texture_from_png (const std::string png_file, const bool flip, GLuint &id)
IGL_INLINE bool	texture_from_png (const std::string png_file, GLuint &id)
IGL_INLINE bool	texture_from_png (const std::string png_file, Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &R, Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &G, Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &B, Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &A)
IGL_INLINE bool	writePNG (const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &R, const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &B, const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &A, const std::string png_file)

Function Documentation

readPNG()

IGL_INLINE bool igl::png::readPNG	(	const std::string	png_file,
		Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	R,
		Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	G,
		Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	B,
		Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	A
	)

{
  int cols,rows,n;
  unsigned char *data = stbi_load(png_file.c_str(), &cols, &rows, &n, 4);
  if(data == NULL) {
    return false;
  }
 
  R.resize(cols,rows);
  G.resize(cols,rows);
  B.resize(cols,rows);
  A.resize(cols,rows);
 
  for (unsigned i=0; i<rows; ++i) {
    for (unsigned j=0; j<cols; ++j) {
      R(j,rows-1-i) = data[4*(j + cols * i) + 0];
      G(j,rows-1-i) = data[4*(j + cols * i) + 1];
      B(j,rows-1-i) = data[4*(j + cols * i) + 2];
      A(j,rows-1-i) = data[4*(j + cols * i) + 3];
    }
  }
 
  igl::stbi_image_free(data);
 
  return true;
}

References Eigen::PlainObjectBase< Derived >::resize().

Here is the call graph for this function:

render_to_png()

IGL_INLINE bool igl::png::render_to_png	(	const std::string	png_file,
		const int	width,
		const int	height,
		const bool	alpha = true,
		const bool	fast = false
	)

{
  unsigned char * data = new unsigned char[4*width*height];
  glReadPixels(
    0,
    0,
    width,
    height,
    GL_RGBA,
    GL_UNSIGNED_BYTE,
    data);
  //img->flip();
  if(!alpha)
  {
    for(int i = 0;i<width;i++)
    for(int j = 0;j<height;j++)
    {
      data[4*(i+j*width)+3] = 255;
    }
  }
  bool ret = igl::stbi_write_png(png_file.c_str(), width, height, 4, data, 4*width*sizeof(unsigned char));
  delete [] data;
  return ret;
}

render_to_png_async()

IGL_INLINE std::thread igl::png::render_to_png_async	(	const std::string	png_file,
		const int	width,
		const int	height,
		const bool	alpha = true,
		const bool	fast = false
	)

{
  // Part that should serial
  unsigned char * data = new unsigned char[width*height];
  glReadPixels(
    0,
    0,
    width,
    height,
    GL_RGBA,
    GL_UNSIGNED_BYTE,
    data);
  // Part that should be asynchronous
  std::thread t(render_to_png_async_helper,data,width,height,png_file,alpha,fast);
  t.detach();
  return t;
}

References render_to_png_async_helper().

Here is the call graph for this function:

texture_from_file()

IGL_INLINE bool igl::png::texture_from_file	(	const std::string	filename,
		GLuint &	id
	)

{
  using namespace igl::opengl;
  using namespace std;
  // dirname, basename, extension and filename
  string d,b,ext,f;
  pathinfo(filename,d,b,ext,f);
  // Convert extension to lower case
  transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
  //if(ext == "tga")
  //{
  //  return texture_from_tga(filename,id);
  //}else 
  if(ext == "png")
  {
    return texture_from_png(filename,id);
  }else
  {
#ifdef __APPLE__
    // Convert to a temporary png file
    string tmp = "/var/tmp/.texture_from_file.png";
#define PATH_TO_CONVERT "/opt/local/bin/convert"
    string command = STR(PATH_TO_CONVERT<<" \""<<filename<<"\" \""<<tmp<<"\"");
    try
    {
      if(system(command.c_str())==0)
      {
        return texture_from_file(tmp.c_str(),id);
      }else
      {
        cerr<<"texture_from_file: calling to convert ('"<<command<<"') failed..."<<endl;
        return false;
      }
    }catch(int e)
    {
      cerr<<"^"<<__FUNCTION__<<": Calling to convert crashed..."<<endl;
      return false;
    }
#else
    return false;
#endif
  }
}

References igl::pathinfo(), STR, texture_from_file(), and texture_from_png().

Referenced by texture_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

texture_from_png() [1/3]

IGL_INLINE bool igl::png::texture_from_png	(	const std::string	png_file,
		const bool	flip,
		GLuint &	id
	)

{
  int width,height,n;
  unsigned char *data = igl::stbi_load(png_file.c_str(), &width, &height, &n, 4);
  if(data == NULL) {
    return false;
  }
 
  // Why do I need to flip?
  /*if(flip)
  {
    yimg.flip();
  }*/
 
  glGenTextures(1, &id);
  glBindTexture(GL_TEXTURE_2D, id);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexImage2D(
    GL_TEXTURE_2D, 0, GL_RGB,
    width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
  glBindTexture(GL_TEXTURE_2D, 0);
 
  igl::stbi_image_free(data);
 
  return true;
}

Referenced by texture_from_file(), and texture_from_png().

Here is the caller graph for this function:

texture_from_png() [2/3]

IGL_INLINE bool igl::png::texture_from_png	(	const std::string	png_file,
		Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	R,
		Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	G,
		Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	B,
		Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	A
	)

{
  int width,height,n;
  unsigned char *data = igl::stbi_load(png_file.c_str(), &width, &height, &n, 4);
  if(data == NULL) {
    return false;
  }
 
  R.resize(height,width);
  G.resize(height,width);
  B.resize(height,width);
  A.resize(height,width);
 
  for (unsigned j=0; j<height; ++j) {
    for (unsigned i=0; i<width; ++i) {
      // used to flip with libPNG, but I'm not sure if
      // simply j*width + i wouldn't be better
      // stb_image uses horizontal scanline an starts top-left corner
      R(i,j) = data[4*( (width-1-i) + width * (height-1-j) )];
      G(i,j) = data[4*( (width-1-i) + width * (height-1-j) ) + 1];
      B(i,j) = data[4*( (width-1-i) + width * (height-1-j) ) + 2];
      //A(i,j) = data[4*( (width-1-i) + width * (height-1-j) ) + 3];
    }
  }
 
  igl::stbi_image_free(data);
 
  return true;
}

References Eigen::PlainObjectBase< Derived >::resize().

Here is the call graph for this function:

texture_from_png() [3/3]

IGL_INLINE bool igl::png::texture_from_png	(	const std::string	png_file,
		GLuint &	id
	)

{
  return texture_from_png(png_file,false,id);
}

References texture_from_png().

Here is the call graph for this function:

writePNG()

IGL_INLINE bool igl::png::writePNG	(	const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	R,
		const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	G,
		const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	B,
		const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	A,
		const std::string	png_file
	)

{
  assert((R.rows() == G.rows()) && (G.rows() == B.rows()) && (B.rows() == A.rows()));
  assert((R.cols() == G.cols()) && (G.cols() == B.cols()) && (B.cols() == A.cols()));
 
  const int comp = 4;                                  // 4 Channels Red, Green, Blue, Alpha
  const int stride_in_bytes = R.rows()*comp;           // Length of one row in bytes
  std::vector<unsigned char> data(R.size()*comp,0);     // The image itself;
 
  for (unsigned i = 0; i<R.rows();++i)
  {
    for (unsigned j = 0; j < R.cols(); ++j)
    {
        data[(j * R.rows() * comp) + (i * comp) + 0] = R(i,R.cols()-1-j);
        data[(j * R.rows() * comp) + (i * comp) + 1] = G(i,R.cols()-1-j);
        data[(j * R.rows() * comp) + (i * comp) + 2] = B(i,R.cols()-1-j);
        data[(j * R.rows() * comp) + (i * comp) + 3] = A(i,R.cols()-1-j);
    }
  }
 
  igl::stbi_write_png(png_file.c_str(), R.rows(), R.cols(), comp, data.data(), stride_in_bytes);
 
  return true;
}

References Eigen::PlainObjectBase< Derived >::cols(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function: