glfTexture2D.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C)  2008, 2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "glfTexture2D.hh"
#include "glfException.hh"
#include <Base/Image/ImageIO.hh>
#include "glfFormatDB.hh"

#include <Gui/biasgl.h>
using namespace BIAS;

// border is currently not used.
const int BORDER_WIDTH = 0;

glfTexture2D::glfTexture2D() :
  glfTexture(GL_TEXTURE_2D)
{ 
              //in the dll case several glew instances might exist.
              //some of them aren't initialized and will deliver false
              //information about the gpu capabilities.
              //until we've found a fix we must initialize glew for every dll              
}

glfTexture2D&
glfTexture2D::operator=(const glfTexture2D& b)
{
  return (*this);
}

glfTexture2D::glfTexture2D(const glfTexture2D& t) :
  glfTexture(GL_TEXTURE_2D)
{
}

void
glfTexture2D::Set(GLenum minFilter, GLenum magFilter, GLenum wrapS,
    GLenum wrapT, GLint textureNr)
{
  SetMinFilter(minFilter);
  SetMagFilter(magFilter);
  SetWrapS(wrapS);
  SetWrapT(wrapT);
  SetTextureNr(textureNr);
}

void
glfTexture2D::UploadImage(const BIAS::ImageBase& image, GLenum internalFormat,
    int mipmap)
{
  if (enlargeToPot_)
    {
      int potWidth = NextPowerOfTwo(image.GetWidth());
      int potHeight = NextPowerOfTwo(image.GetHeight());
      if ((int) image.GetWidth() != potWidth || (int) image.GetHeight()
          != potHeight)
        {
          ImageBase paddedImage;
          image.Pad(paddedImage, potWidth, potHeight);
          UploadImage(paddedImage, internalFormat, mipmap);
          return;
        }
    }

  // choose internal format if none is given
  if (internalFormat == 0)
    {
      internalFormat = glfFormatDB::ProposeInternalFormat(image.GetStorageType(),
          image.GetColorModel());
    }

  // get pixel format and pixel type of given image
  GLenum format = glfFormatDB::GetFormatForColorModel(image.GetColorModel());
  GLenum pixelType = glfFormatDB::GetPixelTypeForStorageType(image.GetStorageType());

  // upload data.
  Bind();
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glTexImage2D(target_, mipmap, internalFormat, image.GetWidth(),
      image.GetHeight(), BORDER_WIDTH, format, pixelType, image.GetImageData());

  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture2D::UploadImageFromFile(const std::string& fileName,
    GLenum internalFormat, int mipmap)
{
  ImageBase image;
  if (ImageIO::Load(fileName, image) != 0)
    {
      GLF_THROW_EXCEPTION("Could not load image: " << fileName);
    }
  UploadImage(image, internalFormat, mipmap);

  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture2D::Allocate(int width, int height, GLenum internalFormat, int mipmap)
{  
  if (enlargeToPot_)
    {
      width = NextPowerOfTwo(width);
      height = NextPowerOfTwo(height);
    }

  GLenum format;
  int numChannels;
  glfFormatDB::GetFormatForInternalFormat(internalFormat, format, numChannels);

  Bind();

  GLenum type = GL_UNSIGNED_BYTE;
  if (internalFormat == GL_DEPTH24_STENCIL8_EXT)
    type = GL_UNSIGNED_INT_24_8_EXT;

  glTexImage2D(target_, mipmap, internalFormat, width, height, BORDER_WIDTH,
      format, type, NULL);

  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture2D::Allocate(int width, int height,
    ImageBase::EStorageType storageType, ImageBase::EColorModel colorModel,
    int mipmap)
{
  GLenum internalFormat = glfFormatDB::ProposeInternalFormat(storageType, colorModel);
  Allocate(width, height, internalFormat, mipmap);
}

void
glfTexture2D::CopyToImage(ImageBase& image, int mipmap)
{
  Bind();

  // get internal format of texture.
  GLenum internalFormat;
  glGetTexLevelParameteriv(target_, mipmap, GL_TEXTURE_INTERNAL_FORMAT,
      (GLint*) &internalFormat);

  // get size
  //  BIASERR("copying texture");
  int width = GetWidth(mipmap);
  int height = GetHeight(mipmap);

  // get format and number of channels
  GLenum format;
  int numChannels;
  glfFormatDB::GetFormatForInternalFormat(internalFormat, format, numChannels);

  // init image with size of texture and appropriate number of channels
  ImageBase::EStorageType storageType = image.GetStorageType();
  if (long(image.GetWidth()) != width || long(image.GetHeight()) != height ||
      long(image.GetChannelCount()) != numChannels)
    {
      image.Init(width, height, numChannels, storageType);
    }

  // get OpenGL pixel type
  GLenum type = glfFormatDB::GetPixelTypeForStorageType(image.GetStorageType());

  glPixelStorei(GL_PACK_ALIGNMENT, 1);
  // copy texture to image
  glGetTexImage(target_, mipmap, format, type, image.GetImageData());

    GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture2D::CopyChannelsToImage(BIAS::ImageBase& image, GLenum format,
    int mipmap)
{
  Bind();

  // get size
  int width = GetWidth(mipmap);
  int height = GetHeight(mipmap);

  // get number of channels
  int numChannels = glfFormatDB::ChannelsFromGLFormat(format);

  // init image with size of texture and appropriate number of channels
  ImageBase::EStorageType storageType = image.GetStorageType();
  if (!image.IsEmpty())
    {
      image.Release(); // ImageBase doesn't like re-Init ...
    }
  image.Init(width, height, numChannels, storageType);

  // get OpenGL pixel type
  GLenum type = glfFormatDB::GetPixelTypeForStorageType(image.GetStorageType());

  glPixelStorei(GL_PACK_ALIGNMENT, 1);
  // copy texture to image
  glGetTexImage(target_, mipmap, format, type, image.GetImageData());

    GLF_THROW_ON_OPENGL_ERROR;
}

int
glfTexture2D::GetWidth(int mipmap) const
{
  GLint width;
  Bind();
  glGetTexLevelParameteriv(target_, mipmap, GL_TEXTURE_WIDTH, &width);
    GLF_THROW_ON_OPENGL_ERROR;
  return width;
}

int
glfTexture2D::GetHeight(int mipmap) const
{
  GLint height;
  Bind();
  glGetTexLevelParameteriv(target_, mipmap, GL_TEXTURE_HEIGHT, &height);
    GLF_THROW_ON_OPENGL_ERROR;
  return height;
}

void
glfTexture2D::DumpUC_RGBA(const std::string& fileName)
{
  Image<unsigned char> dump;
  CopyToImage(dump, 0);
  //ImageIO::Save(fileName, dump);
  ImageIO::Save(fileName, dump);
}