#include <CLSimpleImageTexturizer.h>

Inheritance diagram for CLSimpleImageTexturizer:

Collaboration diagram for CLSimpleImageTexturizer:

Public Member Functions
virtual CLTextureSpec *	operator() (const std::string &filename, const std::string &basedir)

Protected Member Functions
CLTextureSpec *	create_texture_for_image (const std::string &filename, const std::string &basedir)

CLTextureSpec *	create_texture_for_jpeg_image (const std::string &filename)

CLTextureSpec *	create_texture_for_png_image (const std::string &filename)

Additional Inherited Members
Static Protected Member Functions inherited from CLImageTexturizer
static std::string	to_absolute_path (const std::string &filename, const std::string &basedir)

Detailed Description

Definition at line 21 of file CLSimpleImageTexturizer.h.

Member Function Documentation

CLTextureSpec * CLSimpleImageTexturizer::create_texture_for_image	(	const std::string &	filename,
		const std::string &	basedir
	)

protected

This method creates a texture from a given image file. It is up to the caller to free the texture space once it is no longer needed. If no texture could be created, NULL is returned.

Definition at line 26 of file CLSimpleImageTexturizer.cpp.

References create_texture_for_jpeg_image(), create_texture_for_png_image(), CLImageTexturizer::to_absolute_path(), and transform().

Referenced by operator()().

 {
   std::string reference = to_absolute_path(filename, basedir);
   CLTextureSpec* pTexture = NULL;
   // test if the filename ends in "JPG","JPEG","jpeg" or "jpg"
   std::string::size_type pos = reference.rfind(".");
   std::string ending;
 
   if (pos != std::string::npos)
     {
       ++pos;
       ending = reference.substr(pos);
       std::transform(ending.begin(), ending.end(), ending.begin(), (int(*)(int))std::tolower);
     }
 
   if (!ending.empty())
     {
       if (ending == "jpeg" || ending == "jpg")
         {
           pTexture = create_texture_for_jpeg_image(reference);
         }
       else if (ending == "png") // test if the filename ends in "PNG" or "png"
         {
           pTexture = create_texture_for_png_image(reference);
         }
     }
 
   return pTexture;
 }

CLTextureSpec * CLSimpleImageTexturizer::create_texture_for_jpeg_image ( const std::string & filename )

protected

This method creates a texture from a given JPEG image file. It is up to the caller to free the texture space once it is no longer needed. If no texture could be created, NULL is returned.

Definition at line 61 of file CLSimpleImageTexturizer.cpp.

References GL_CLAMP_TO_EDGE, CLTextureSpec::mNumComponents, CLTextureSpec::mTextHeight, CLTextureSpec::mTextureHeight, CLTextureSpec::mTextureName, CLTextureSpec::mTextureWidth, and CLTextureSpec::mTextWidth.

Referenced by create_texture_for_image().

 {
   CLTextureSpec* pTexture = NULL;
   FILE *fp = fopen(filename.c_str(), "rb");
 
   if (fp)
     {
       struct jpeg_decompress_struct cinfo;
       struct jpeg_error_mgr jerr;
       cinfo.err = jpeg_std_error(&jerr);
       jpeg_create_decompress(&cinfo);
       jpeg_stdio_src(&cinfo, fp);
       jpeg_read_header(&cinfo, true);
       cinfo.out_color_space = JCS_RGB;
       jpeg_start_decompress(&cinfo);
       // read the size and allocate the memory needed
       unsigned int width = cinfo.output_width;
       assert(cinfo.output_components == 3);
       unsigned int row_stride = width * cinfo.output_components;
       unsigned int height = cinfo.output_height;
       pTexture = new CLTextureSpec();
       pTexture->mTextureWidth = width;
       pTexture->mTextureHeight = height;
       pTexture->mTextureName = 0;
       pTexture->mNumComponents = 3;
       GLubyte* pData = new GLubyte[3 * width * height];
       JSAMPARRAY buffer = (*cinfo.mem->alloc_sarray)
                           ((j_common_ptr) & cinfo, JPOOL_IMAGE, row_stride, 1);
 
       while (cinfo.output_scanline < cinfo.output_height)
         {
           jpeg_read_scanlines(&cinfo, buffer, 1);
           memcpy(pData + (cinfo.output_scanline - 1)*row_stride, buffer[0], row_stride);
         }
 
       jpeg_finish_decompress(&cinfo);
       jpeg_destroy_decompress(&cinfo);
       fclose(fp);
 
       // right now the texture is not a power of two, but it has the same size as the image
       // we need to scale it to a power of two, for this we check which size of the texture
       // supported by the OpenGL implementation and rescale it
       GLint w = 0;
       width = (unsigned int)ceil(log(pTexture->mTextureWidth) / log(2.0));
       height = (unsigned int)ceil(log(pTexture->mTextureHeight) / log(2.0));
       width = (1 << width);
       height = (1 << height);
       GLenum format = GL_RGB;
       GLint internalFormat = GL_RGB;
       glTexImage2D(GL_PROXY_TEXTURE_2D, 0, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
       glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
 
       while (w == 0 && width > 0 && height > 0)
         {
           // divide the size by two in each direction
           width = width >> 1;
           height = height >> 1;
           glTexImage2D(GL_PROXY_TEXTURE_2D, 0, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
           glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
         }
 
       if (w == 0)
         {
           // delete the texture since we can not draw it anyway
           delete pTexture;
           pTexture = NULL;
         }
       else if (w != pTexture->mTextureWidth)
         {
           if (w < pTexture->mTextureWidth)
             {
               // create a warning that the texture had to be scaled down
               std::cerr << "Image texture to large. Scaling down to size that is supported by current OpenGL implementation." << std::endl;
             }
 
           // rescale the texture
           GLubyte* newData = new GLubyte[pTexture->mNumComponents * width * height];
 
           if (gluScaleImage(format, (GLint)pTexture->mTextureWidth, (GLint)pTexture->mTextureHeight, GL_UNSIGNED_BYTE, pData, width, height, GL_UNSIGNED_BYTE, newData) == 0)
             {
               delete[] pData;
               pData = newData;
               pTexture->mTextureWidth = width;
               pTexture->mTextureHeight = height;
               pTexture->mTextWidth = pTexture->mTextureWidth;
               pTexture->mTextHeight = pTexture->mTextureHeight;
             }
           else
             {
               // an error has occured
               delete[] newData;
               delete pTexture;
               pTexture = NULL;
             }
 
           if (pTexture != NULL)
             {
               glGenTextures(1, &pTexture->mTextureName);
               assert(pTexture->mTextureName != 0);
               glBindTexture(GL_TEXTURE_2D, pTexture->mTextureName);
               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
               glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, (GLsizei)pTexture->mTextureWidth, (GLsizei)pTexture->mTextureHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pData);
             }
         }
 
       delete[] pData;
     }
 
   return pTexture;
 }

CLTextureSpec * CLSimpleImageTexturizer::create_texture_for_png_image ( const std::string & filename )

protected

This method creates a texture from a given PNG image file. It is up to the caller to free the texture space once it is no longer needed. If no texture could be created, NULL is returned.

Definition at line 181 of file CLSimpleImageTexturizer.cpp.

References GL_CLAMP_TO_EDGE, CLTextureSpec::mNumComponents, CLTextureSpec::mTextHeight, CLTextureSpec::mTextureHeight, CLTextureSpec::mTextureName, CLTextureSpec::mTextureWidth, and CLTextureSpec::mTextWidth.

Referenced by create_texture_for_image().

 {
   CLTextureSpec* pTexture = NULL;
   FILE *fp = fopen(filename.c_str(), "rb");
 
   if (fp)
     {
       png_byte header[8];
       fread(header, 1, 8, fp);
 
       if (!png_sig_cmp(header, 0, 8))
         {
           png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 
           if (png_ptr)
             {
               png_infop info_ptr = png_create_info_struct(png_ptr);
               png_infop end_info = NULL;
 
               if (info_ptr)
                 {
                   end_info = png_create_info_struct(png_ptr);
 
                   if (end_info)
                     {
                       png_init_io(png_ptr, fp);
                       png_set_sig_bytes(png_ptr, 8);
                       png_read_info(png_ptr, info_ptr);
                       unsigned int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
                       unsigned int color_type = png_get_color_type(png_ptr, info_ptr);
 
                       // convert a palette to an RGB image
                       if (color_type == PNG_COLOR_TYPE_PALETTE)
                         {
                           png_set_palette_to_rgb(png_ptr);
                         }
 
                       // convert low bit_depth grayscale images to 8 Bit
                       if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
                         {
                           png_set_gray_1_2_4_to_8(png_ptr);
                         }
 
                       // add an alpha channel from info
                       if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
                         {
                           png_set_tRNS_to_alpha(png_ptr);
                         }
 
                       // convert 16Bit images to 8 Bit
                       if (bit_depth == 16)
                         {
                           png_set_strip_16(png_ptr);
                         }
 
                       // convert low bit_depth images to 8 Bit
                       if (bit_depth < 8)
                         {
                           png_set_packing(png_ptr);
                         }
 
                       // convert grayscale to RGB
                       if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
                         {
                           png_set_gray_to_rgb(png_ptr);
                         }
 
                       // add an alpha channel to RGB images
                       if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_GRAY)
                         {
                           png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
                         }
 
                       // enable interlace handling to expand the image if it
                       // is interlaced
                       /*unsigned int num_passes=*/png_set_interlace_handling(png_ptr);
                       // now we reread the info and get the width and height
                       // in order to allocate enough memory
                       png_read_update_info(png_ptr, info_ptr);
                       unsigned int width = png_get_image_width(png_ptr, info_ptr);
                       unsigned int height = png_get_image_height(png_ptr, info_ptr);
 
                       if (height > 0)
                         {
                           // create the texture object
                           pTexture = new CLTextureSpec();
                           // we have to reserve enough memory for a width*height
                           // RGBA image
                           GLubyte* pData = new GLubyte[4 * width * height];
                           pTexture->mTextureWidth = width;
                           pTexture->mTextureHeight = height;
                           pTexture->mNumComponents = 4;
                           pTexture->mTextureName = 0;
                           // create an array with pointers to the rows
                           png_bytepp pRow_pointers = new png_bytep[height];
                           unsigned int i;
 
                           for (i = 0; i < height; ++i)
                             {
                               pRow_pointers[i] = (&(pData[4 * width * i]));
                             }
 
                           png_read_image(png_ptr, pRow_pointers);
                           png_read_end(png_ptr, end_info);
                           fclose(fp);
                           // right now the texture is not a power of two, but it has the same size as the image
                           // we need to scale it to a power of two, for this we check which size of the texture
                           // supported by the OpenGL implementation and rescale it
                           GLint w = 0;
                           width = (unsigned int)ceil(log(pTexture->mTextureWidth) / log(2.0));
                           height = (unsigned int)ceil(log(pTexture->mTextureHeight) / log(2.0));
                           width = (1 << width);
                           height = (1 << height);
                           GLenum format = GL_RGBA;
                           GLint internalFormat = GL_RGBA;
                           glTexImage2D(GL_PROXY_TEXTURE_2D, 0, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
                           glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
 
                           while (w == 0 && width > 0 && height > 0)
                             {
                               // divide the size by two in each direction
                               width = width >> 1;
                               height = height >> 1;
                               glTexImage2D(GL_PROXY_TEXTURE_2D, 0, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
                               glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
                             }
 
                           if (w == 0)
                             {
                               // delete the texture since we can not draw it anyway
                               delete pTexture;
                               pTexture = NULL;
                             }
                           else if (w != pTexture->mTextureWidth)
                             {
                               if (w < pTexture->mTextureWidth)
                                 {
                                   // create a warning that the texture had to be scaled down
                                   std::cerr << "Image texture to large. Scaling down to size that is supported by current OpenGL implementation." << std::endl;
                                 }
 
                               // rescale the texture
                               GLubyte* newData = new GLubyte[pTexture->mNumComponents * width * height];
 
                               if (gluScaleImage(format, (GLint)pTexture->mTextureWidth, (GLint)pTexture->mTextureHeight, GL_UNSIGNED_BYTE, pData, width, height, GL_UNSIGNED_BYTE, newData) == 0)
                                 {
                                   delete[] pData;
                                   pData = newData;
                                   pTexture->mTextureWidth = width;
                                   pTexture->mTextureHeight = height;
                                   pTexture->mTextWidth = pTexture->mTextureWidth;
                                   pTexture->mTextHeight = pTexture->mTextureHeight;
                                 }
                               else
                                 {
                                   // an error has occured
                                   delete[] newData;
                                   delete pTexture;
                                   pTexture = NULL;
                                 }
 
                               if (pTexture != NULL)
                                 {
                                   glGenTextures(1, &pTexture->mTextureName);
                                   assert(pTexture->mTextureName != 0);
                                   glBindTexture(GL_TEXTURE_2D, pTexture->mTextureName);
                                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
                                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
                                   glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
                                   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, (GLsizei)pTexture->mTextureWidth, (GLsizei)pTexture->mTextureHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pData);
                                 }
                             }
 
                           delete[] pData;
                           delete[] pRow_pointers;
                         }
                     }
                 }
 
               // delete the png structures again
               png_destroy_read_struct(&png_ptr, (png_infopp)&info_ptr, (png_infopp)&end_info);
             }
         }
     }
 
   return pTexture;
 }

CLTextureSpec * CLSimpleImageTexturizer::operator()	(	const std::string &	filename,
		const std::string &	basedir
	)

virtual

Implements CLImageTexturizer.

Definition at line 16 of file CLSimpleImageTexturizer.cpp.

References create_texture_for_image().

 {
   return this->create_texture_for_image(filename, basedir);
 }

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation