rtcTexture.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2008
 * Robert Bosch LLC
 * Research and Technology Center North America
 * Palo Alto, California
 *
 * All rights reserved.
 *
 *------------------------------------------------------------------------------
 * project ....: PUMA: Probablistic Unsupervised Model Acquisition
 * file .......: Texture.cpp
 * authors ....: Benjamin Pitzer
 * organization: Robert Bosch LLC
 * creation ...: 10/13/2006
 * modified ...: $Date: 2009-02-02 12:17:10 -0800 (Mon, 02 Feb 2009) $
 * changed by .: $Author: wg75pal $
 * revision ...: $Revision: 772 $
 */

//== INCLUDES ==================================================================
#ifdef _MSC_VER
#       include <windows.h>
#endif
#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "rtc/rtcTexture.h"
#include <rtc/rtcBase.h>

//== NAMESPACES ================================================================
namespace rtc {

//== IMPLEMENTATION ============================================================

Texture::Texture(bool _multi_use, int _max_texture_size)
: multi_use(_multi_use),max_texture_size(_max_texture_size),texture_id(0),
  texture_width(0),texture_height(0),image_width(0),image_height(0),max_u(0),
  max_v(0),texture_data(NULL)
{
}

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

void Texture::create(int width, int height)
{
  texture_width = 1;
  texture_height = 1;
  while(texture_width < width)
    texture_width *= 2;
  while(texture_height < height)
    texture_height *= 2;
  image_width = width;
  image_height = height;
  texture_data = (unsigned char *)calloc(1, 4 * texture_width * texture_height);
  rtc_test_alloc(texture_data);

  max_u = width / (float)texture_width;
  max_v = height / (float)texture_height;

  if (texture_id==0)
    glGenTextures(1, &texture_id);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glBindTexture(GL_TEXTURE_2D, texture_id);

  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}

void Texture::update()
{
  if(texture_data == NULL)
    rtc_die("Error: cannont update a single use texture.\n");
  glBindTexture(GL_TEXTURE_2D, texture_id);
  glTexImage2D(GL_TEXTURE_2D, 0, 4, texture_width,
               texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
               texture_data);
}

void Texture::updateRGBA()
{
  if(texture_data == NULL)
    rtc_die("Error: cannont update a single use texture.\n");
  glBindTexture(GL_TEXTURE_2D, texture_id);
  glTexImage2D(GL_TEXTURE_2D, 0, 4, texture_width,
               texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
               texture_data);
}

void Texture::createRGBA(int width, int height)
{
  texture_width = 1;
  texture_height = 1;
  while(texture_width < width)
    texture_width *= 2;
  while(texture_height < height)
    texture_height *= 2;
  image_width = width;
  image_height = height;
  texture_data = (unsigned char *)calloc(1, 4 * texture_width * texture_height);
  rtc_test_alloc(texture_data);

  max_u = width / (float)texture_width;
  max_v = height / (float)texture_height;

  glGenTextures(1, &texture_id);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glBindTexture(GL_TEXTURE_2D, texture_id);

  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}

void Texture::draw()
{
  glEnable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D, texture_id);
  glColor3f(1, 1, 1);
  glBegin(GL_POLYGON);
  glTexCoord2f(0, 0);
  glVertex2f(-1, 1);
  glTexCoord2f(0, 1);
  glVertex2f(-1, -1);
  glTexCoord2f(1, 1);
  glVertex2f(1, -1);
  glTexCoord2f(1, 0);
  glVertex2f(1, 1);
  glEnd();
  glDisable(GL_TEXTURE_2D);
}

void Texture::draw2(double x1, double y1,
                    double x2, double y2,
                    double x3, double y3,
                    double x4, double y4)
{
  glEnable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D, texture_id);
  glColor3f(1, 1, 1);
  glBegin(GL_POLYGON);
  glTexCoord2f(0, max_v);
  glVertex2f(x1, y1);
  glTexCoord2f(max_u, max_v);
  glVertex2f(x2, y2);
  glTexCoord2f(max_u, 0);
  glVertex2f(x3, y3);
  glTexCoord2f(0, 0);
  glVertex2f(x4, y4);
  glEnd();
  glDisable(GL_TEXTURE_2D);
}

void Texture::fromImage(const Image3uc& image)
{
  texture_width = 1;
  texture_height = 1;
  while(texture_width < image.columns())
    texture_width *= 2;
  while(texture_height < image.rows())
    texture_height *= 2;
  if(texture_height > max_texture_size)
    texture_height = max_texture_size;
  if(texture_width > max_texture_size)
    texture_width = max_texture_size;

  Image3uc newimage(texture_height,texture_width);
  image.resized(newimage);
  unsigned char *data=new unsigned char[texture_height*texture_width*3];
  for (int i=0;i<texture_height*texture_width;i++)
  {
    data[i*3]=newimage.x[i][0];
    data[i*3+1]=newimage.x[i][1];
    data[i*3+2]=newimage.x[i][2];
  }

  if (texture_id==0) glGenTextures(1, &texture_id);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glBindTexture(GL_TEXTURE_2D, texture_id);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,newimage.columns(),newimage.rows(),0,GL_RGB,GL_UNSIGNED_BYTE,data);
  
  delete data;


  if(!multi_use) {
//     free(texture_data);
//     texture_data = NULL;
  }
}

void Texture::fromImage(const Image4uc& image)
{
  texture_width = 1;
  texture_height = 1;
  while(texture_width < image.columns())
    texture_width *= 2;
  while(texture_height < image.rows())
    texture_height *= 2;
  if(texture_height > max_texture_size)
    texture_height = max_texture_size;
  if(texture_width > max_texture_size)
    texture_width = max_texture_size;

  Image4uc newimage(texture_height,texture_width);
  image.resized(newimage);
  texture_data=new unsigned char[texture_height*texture_width*4];
  for (int i=0;i<texture_height*texture_width;i++)
  {
      texture_data[i*4]=newimage.x[i][0];
      texture_data[i*4+1]=newimage.x[i][1];
      texture_data[i*4+2]=newimage.x[i][2];
      texture_data[i*4+3]=newimage.x[i][3];
  }

  if (texture_id==0) glGenTextures(1, &texture_id);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glBindTexture(GL_TEXTURE_2D, texture_id);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,newimage.columns(),newimage.rows(),0,GL_RGBA,GL_UNSIGNED_BYTE,texture_data);
  glDisable(GL_TEXTURE_2D);

  if(!multi_use) {
    //     free(texture_data);
    //     texture_data = NULL;
  }
}

void Texture::toImage(Image4uc& image)
{
    image.setSize(texture_height, texture_width);
    int size = texture_height*texture_width;
    for (int i=0;i<size;i++)
    {
        image.x[i][0] = texture_data[i*4];
        image.x[i][1] = texture_data[i*4+1];
        image.x[i][2] = texture_data[i*4+2];
        image.x[i][3] = texture_data[i*4+3];
    }
}

bool Texture::loadFromImage(const char *filename)
{
  // read the image from file
  Image4uc image;
  bool res = image.readFromFile(filename);
  if(!res) return false;
  // load from image
  fromImage(image);
  return true;
}

bool Texture::saveToImage(const char* filename)
{
    // convert texture to image
    Image4uc image;
    toImage(image);
    return image.writeToFile(filename);
}

bool Texture::write(std::ostream& os, bool ascii) const
{
  return true;
}

bool Texture::read(std::istream& is, bool ascii)
{
  return true;
}

void Texture::bind( GLenum target/*=GL_TEXTURE0*/ )
{
  glEnable(GL_TEXTURE_2D);
  glActiveTexture(target);
  glBindTexture(GL_TEXTURE_2D, texture_id);
  bind_target=target;
}

void Texture::unbind()
{
  glActiveTexture(bind_target);
  glBindTexture(GL_TEXTURE_2D,0);
  glDisable(GL_TEXTURE_2D);
}

void Texture::unloadTexture()
{
  if (texture_id!=0) glDeleteTextures(1, &texture_id);
  texture_id=0;
  if(texture_data != NULL)
    free(texture_data);
}
//==============================================================================
} // namespace rtc
//==============================================================================