glfFormatDB.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 "glfFormatDB.hh"
#include "glfException.hh"

using namespace BIAS;


void glfFormatDB::
    GetFormatForInternalFormat(GLenum internalFormat,
                               GLenum& format,
                               int& numChannels)
{
  switch (internalFormat)
  {
#ifdef GL_VERSION_3_0
  case GL_R32F:
    format = GL_RED;
    numChannels = 1;
    break;
#endif

  case GL_ALPHA:
  case GL_ALPHA4:
  case GL_ALPHA8:
  case GL_ALPHA12:
  case GL_ALPHA16:
  case GL_COMPRESSED_ALPHA:
  case GL_INTENSITY:
  case GL_INTENSITY4:
  case GL_INTENSITY8:
  case GL_INTENSITY12:
  case GL_INTENSITY16:
  case GL_COMPRESSED_INTENSITY:
    format = GL_ALPHA;
    numChannels = 1;
    break;

  case GL_LUMINANCE:
  case GL_LUMINANCE4:
  case GL_LUMINANCE8:
  case GL_LUMINANCE12:
  case GL_LUMINANCE16:
    //case GL_SLUMINANCE:
    //case GL_SLUMINANCE8:
  case GL_COMPRESSED_LUMINANCE:
  case GL_LUMINANCE16F_ARB:
  case GL_LUMINANCE32F_ARB:
    //format = GL_LUMINANCE;
    format = GL_RED;
    numChannels = 1;
    break;

  case GL_LUMINANCE_ALPHA:
  case GL_LUMINANCE4_ALPHA4:
  case GL_LUMINANCE6_ALPHA2:
  case GL_LUMINANCE8_ALPHA8:
  case GL_LUMINANCE12_ALPHA4:
  case GL_LUMINANCE12_ALPHA12:
  case GL_LUMINANCE16_ALPHA16:
    //case GL_SLUMINANCE_ALPHA:
    //case GL_SLUMINANCE8_ALPHA8:
  case GL_COMPRESSED_LUMINANCE_ALPHA:
  case GL_LUMINANCE_ALPHA16F_ARB:
  case GL_LUMINANCE_ALPHA32F_ARB:
    format = GL_LUMINANCE_ALPHA;
    numChannels = 2;
    break;

  case GL_R3_G3_B2:
  case GL_RGB:
  case GL_RGB4:
  case GL_RGB5:
  case GL_RGB8:
  case GL_RGB10:
  case GL_RGB12:
  case GL_RGB16:
    //case GL_SRGB:
    //case GL_SRGB8:
  case GL_COMPRESSED_RGB:
  case GL_RGB16F_ARB:
  case GL_RGB32F_ARB:
    format = GL_RGB;
    numChannels = 3;
    break;

  case GL_RGBA:
  case GL_RGBA2:
  case GL_RGBA4:
  case GL_RGB5_A1:
  case GL_RGBA8:
  case GL_RGB10_A2:
  case GL_RGBA12:
  case GL_RGBA16:
    //case GL_SRGB_ALPHA:
    //case GL_SRGB8_ALPHA8:
  case GL_COMPRESSED_RGBA:
  case GL_RGBA16F_ARB:
  case GL_RGBA32F_ARB:
    format = GL_RGBA;
    numChannels = 4;
    break;

  case GL_RGBA8UI:
      format = GL_RGBA_INTEGER;
      numChannels = 4;
      break;

  case GL_DEPTH_COMPONENT:
  case GL_DEPTH_COMPONENT16:
  case GL_DEPTH_COMPONENT24:
  case GL_DEPTH_COMPONENT32:
    format = GL_DEPTH_COMPONENT;
    numChannels = 1;
    break;
  case GL_DEPTH24_STENCIL8_EXT:
    format = GL_DEPTH_STENCIL_EXT;
    numChannels = 2;
    break;

  default:
    GLF_THROW_EXCEPTION("Unknown or invalid internal texture format")
        ;
    break;
  }
}

GLenum glfFormatDB::
    GetPixelTypeForStorageType(ImageBase::EStorageType storageType)
{
  switch (storageType)
  {
  case ImageBase::ST_invalid:
    GLF_THROW_EXCEPTION("Invalid storage type")
        ;
    break;
  case ImageBase::ST_unsignedchar:
    return GL_UNSIGNED_BYTE;
  case ImageBase::ST_char:
    return GL_BYTE;
  case ImageBase::ST_unsignedshortint:
    return GL_UNSIGNED_SHORT;
  case ImageBase::ST_shortint:
    return GL_SHORT;
  case ImageBase::ST_unsignedint:
    return GL_UNSIGNED_INT;
  case ImageBase::ST_int:
    return GL_INT;
  case ImageBase::ST_float:
    return GL_FLOAT;
  case ImageBase::ST_double:
    GLF_THROW_EXCEPTION("Storage type 'double' is not supported by OpenGL")
        ;
    break;
  default:
    GLF_THROW_EXCEPTION("Unknown storage type")
        ;
    break;
  }
}

GLenum glfFormatDB::
    GetFormatForColorModel(ImageBase::EColorModel colorModel)
{
  switch (colorModel)
  {
  case ImageBase::CM_Grey:
  case ImageBase::CM_Depth:
  case ImageBase::CM_Disparity:
    return GL_LUMINANCE;
  case ImageBase::CM_GreyA:
    return GL_LUMINANCE_ALPHA;
  case ImageBase::CM_RGB:
    return GL_RGB;
  case ImageBase::CM_RGBA:
    return GL_RGBA;
  case ImageBase::CM_BGR:
    return GL_BGR;
  case ImageBase::CM_BGRA:
    return GL_BGRA;
  case ImageBase::CM_LUV:
  case ImageBase::CM_LAB:
    return GL_RGB;
  default:
    GLF_THROW_EXCEPTION("Color model " << colorModel << " is not supported by OpenGL or unknown")
        ;
  }
}

GLenum glfFormatDB::
    ProposeInternalFormat(ImageBase::EStorageType storageType,
                          ImageBase::EColorModel colorModel)
{

  if (storageType == ImageBase::ST_float)
  {
    switch (colorModel)
    {
    case ImageBase::CM_Grey:
    case ImageBase::CM_Depth:
    case ImageBase::CM_Disparity:
      return GL_LUMINANCE32F_ARB;
    case ImageBase::CM_GreyA:
      return GL_LUMINANCE_ALPHA32F_ARB;
    case ImageBase::CM_RGB:
    case ImageBase::CM_LUV:
    case ImageBase::CM_LAB:
    case ImageBase::CM_BGR:
      return GL_RGB32F_ARB;
    case ImageBase::CM_RGBA:
    case ImageBase::CM_BGRA:
      return GL_RGBA32F_ARB;

    default:
      break; // suppress warning
    }
  }

  if (storageType == ImageBase::ST_unsignedchar || storageType
      == ImageBase::ST_unsignedshortint || storageType
      == ImageBase::ST_unsignedint)
  {
    switch (colorModel)
    {
    case ImageBase::CM_Grey:
      return GL_LUMINANCE;
    case ImageBase::CM_GreyA:
      return GL_LUMINANCE_ALPHA;
    case ImageBase::CM_RGB:
    case ImageBase::CM_BGR:
      return GL_RGB;
    case ImageBase::CM_RGBA:
    case ImageBase::CM_BGRA:
      return GL_RGBA;
    default:
      break; // suppress warning
    }
  }

  GLF_THROW_EXCEPTION("Could not find appropriate OpenGL pixel format for "
                      "storage type " << storageType << " and color model "
                      << colorModel);

}

GLenum glfFormatDB::
    GLenumFromString(const std::string& enumString)
{
  
  if(enumString == "GL_RED") return GL_RED;
  if(enumString == "GL_GREEN") return GL_GREEN;
  if(enumString == "GL_BLUE") return GL_BLUE;

  if(enumString == "GL_RGB") return GL_RGB;
  if(enumString == "GL_RGBA") return GL_RGBA;

  if(enumString == "GL_LUMINANCE_ALPHA32F_ARB") return GL_LUMINANCE_ALPHA32F_ARB;
  if(enumString == "GL_RGB32F" || enumString == "GL_RGB32F_ARB") return GL_RGB32F_ARB;
  if(enumString == "GL_RGBA32F" || enumString == "GL_RGBA32F_ARB") return GL_RGBA32F_ARB;


  if(enumString == "GL_CLAMP") return GL_CLAMP;
  if(enumString == "GL_CLAMP_TO_BORDER") return GL_CLAMP_TO_BORDER;
  if(enumString == "GL_REPEAT") return GL_REPEAT;

  if(enumString == "GL_NEAREST") return GL_NEAREST;
  if(enumString == "GL_LINEAR") return GL_LINEAR;
  if(enumString == "GL_NEAREST_MIPMAP_NEAREST") return GL_NEAREST_MIPMAP_NEAREST;
  if(enumString == "GL_LINEAR_MIPMAP_NEAREST") return GL_LINEAR_MIPMAP_NEAREST;
  if(enumString == "GL_LINEAR_MIPMAP_LINEAR") return GL_LINEAR_MIPMAP_LINEAR;

  if(enumString == "GL_LESS") return GL_LESS;
  if(enumString == "GL_LEQUAL") return GL_LEQUAL;
  if(enumString == "GL_GREATER") return GL_GREATER;
  if(enumString == "GL_GEQUAL") return GL_GEQUAL;
  

  BIASERR("enumString could not be matched!");
  return GL_INVALID_ENUM;
}

int glfFormatDB::ChannelsFromGLFormat(GLenum textureFormat)
{
  int numChannels = 0;
  switch (textureFormat)
  {
  case GL_RED:
  case GL_GREEN:
  case GL_BLUE:
  case GL_ALPHA:
  case GL_LUMINANCE:
    numChannels = 1;
    break;
  case GL_LUMINANCE_ALPHA:
    numChannels = 2;
    break;
  case GL_RGB:
  case GL_BGR:
    numChannels = 3;
    break;
  case GL_RGBA:
  case GL_BGRA:
    numChannels = 4;
    break;
  default:
    GLF_THROW_EXCEPTION("Invalid or unknown format");
        ;
    break;
  }
  return numChannels;
}