SceneBGImage.cpp

#include "SceneBGImage.hh"

#include <bias_config.h>
#include <Gui/biasgl.h>
#include <Base/Image/ImageConvert.hh>
#include <Base/Image/ImageIO.hh>
//#include <Base/Debug/TimeMeasure.hh>
#include <Filter/Rescale.hh>
#include <Base/Common/FileHandling.hh>

using namespace std;
using namespace BIAS;

SceneBGImage::
SceneBGImage()
{
  IsInitialized_ = false;
  IsActive_ = true;
  BackgroundImageTex_ = 0;
  ImgWidth_ = ImgHeight_ = 0;
  MaxTextureSize_ = 0;
  MinFilter_ = GL_NEAREST;
  MagFilter_ = GL_NEAREST;
}


int SceneBGImage::
SetImage(const Image<unsigned char> &img)
{
  //TimeMeasure timer;
  //timer.Start();
  Image <unsigned char> tmp[2];
  unsigned char current=0,next=1;
  if((img.GetColorModel() != ImageBase::CM_Grey) &&
     (img.GetColorModel() != ImageBase::CM_RGB) &&
     (img.GetColorModel() != ImageBase::CM_BGR) ) {
    if(ImageConvert::ToRGB(img, tmp[current])!= 0) {
      BIASERR("Unsupported color model");
      return -1;
    }
  }else{
    // take copy even if rgb, because PadToPowerOfTwo() will modify image
    // stringstream sstr;
    //sstr << "SceneBGImage::SetImage() StorageTypes: img = " << img.GetStorageType() << ", tmp = " << tmp[current].GetStorageType();
    // cout << sstr.str() << endl;
    //BEXCEPTION( sstr.str() );
    tmp[current]=img;
  }
  if (MaxTextureSize_ == 0)
  glGetIntegerv(GL_MAX_TEXTURE_SIZE,&MaxTextureSize_);
  //  cout <<"OpenGL reports MAX_TEXTURE_SIZE: "<<MaxTextureSize_<<endl;
  // max_texture_size = 2048; // be conservative
  if (tmp[current].GetWidth()>(unsigned)MaxTextureSize_
      || tmp[current].GetHeight()>(unsigned)MaxTextureSize_){
    // BIASERR("image too big, downsampling");
    // downsample
    Rescale<unsigned char, unsigned char> rescale;
    do {
      if (rescale.DownsampleBy2(tmp[current],tmp[next])!=0){
        BIASERR("error downsampling");
      }
      // swap current and next indeces
      unsigned char ttt=next;
      next = current;
      current = ttt;
    } while (tmp[current].GetWidth()>(unsigned)MaxTextureSize_ ||
             tmp[current].GetHeight()>(unsigned)MaxTextureSize_);

  }

  // timer.Stop();
  // cout << "SceneBGImage: rescale: "<<timer.GetRealTime()<<" us\n";
  // timer.Reset();
  // timer.Start();

  if(tmp[current].GetWidth() != ImgWidth_
     || tmp[current].GetHeight()!= ImgHeight_){
    return InitializeTexture_(tmp[current]);
  }

  if (!IsInitialized_){
    return InitializeTexture_(tmp[current]);
  } else {
    // check width and height and eventually reinit texture
    glBindTexture(GL_TEXTURE_2D, BackgroundImageTex_);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glPixelStorei(GL_PACK_ALIGNMENT, 1);

    // need to be power of two
    tmp[current].PadToPowerOfTwo(255);
    // timer.Stop();
    // cout << "SceneBGImage: pad: "<<timer.GetRealTime()<<" us\n";
    // timer.Reset();
    // timer.Start();
      {GLenum err = glGetError();  if (err != GL_NO_ERROR) { BIASERR("OpenGL Error before TexSubImage: " << gluErrorString(err));}}

    if (tmp[current].GetChannelCount() ==3){
      switch(tmp[current].GetColorModel()){
      case ImageBase::CM_RGB:
        glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0,tmp[current].GetWidth(),
                         tmp[current].GetHeight(), GL_RGB, GL_UNSIGNED_BYTE,
                         tmp[current].GetImageData());
        break;
      case ImageBase::CM_BGR:
        glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0,tmp[current].GetWidth(),
                         tmp[current].GetHeight(), GL_BGR, GL_UNSIGNED_BYTE,
                         tmp[current].GetImageData());
        break;
      default:
        cerr << "invalid color model\n";
        ABORT;
        break;
      }
    }
   else  if  (tmp[current].GetChannelCount() ==1)
      glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0,tmp[current].GetWidth(),
                       tmp[current].GetHeight(), GL_LUMINANCE, GL_UNSIGNED_BYTE,
                       tmp[current].GetImageData());
    else {
      BIASERR("Can not handle texture with "<<tmp[current].GetChannelCount()
              <<" channels and Colormodel:"<<tmp[current].GetColorModel());
      return -1;
    }
      {GLenum err = glGetError();  if (err != GL_NO_ERROR) { BIASERR("OpenGL Error after TexSubImage: " << gluErrorString(err));}}

  }
  // timer.Stop();
  // cout << "SceneBGImage: texture: "<<timer.GetRealTime()<<" us\n";
  // timer.Reset();
  // timer.Start();

  return 0;
}

int SceneBGImage::
InitializeTexture_(Image<unsigned char> img)
{
  Image<unsigned char> imgtmp;

  //convert if necessary
  if((img.GetColorModel() != ImageBase::CM_Grey) &&
     (img.GetColorModel() != ImageBase::CM_RGB)) {
    if(ImageConvert::ToRGB(img, imgtmp)!= 0) {
      BIASERR("Unsupported color model");
      return -1;
    }
  }else{
    // take copy even if rgb, because PadToPowerOfTwo() will modify image
    imgtmp=img;
  }

  //ignores 0's and names that do not correspond to existing textures
  glDeleteTextures(1, &BackgroundImageTex_);
  glGenTextures(1, &BackgroundImageTex_);
  float maxtexcoordX, maxtexcoordY;

  // save orig image size to detect changed input data
  ImgWidth_ = imgtmp.GetWidth();
  ImgHeight_ = imgtmp.GetHeight();
  if(ImgWidth_ == 0 || ImgHeight_ == 0) {
    BIASERR("Image has zero dimension! Moving to uninitialized state.");
    IsInitialized_ = false;
    return -1;
  }
  // cout <<"downsampled imagesize:"<<img.GetWidth()<<" x "<<img.GetHeight()<<endl;
  // img is a copy, so we can modify it
  img.PadToPowerOfTwo(255);

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glPixelStorei(GL_PACK_ALIGNMENT, 1);

  glBindTexture(GL_TEXTURE_2D, BackgroundImageTex_);

  if (img.GetChannelCount() == 3){
    switch (img.GetColorModel()){
    case ImageBase::CM_RGB:
      glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, img.GetWidth(),img.GetHeight() , 0,
                   GL_RGB,GL_UNSIGNED_BYTE, img.GetImageData());
      break;
    case ImageBase::CM_BGR:
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, img.GetWidth(),img.GetHeight() , 0,
                   GL_BGR, GL_UNSIGNED_BYTE, img.GetImageData());
      break;
    default:
      cerr << "unsupported color model\n";
      ABORT;
      break;
    }
  }
  else if (img.GetChannelCount() == 1)
    glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, imgtmp.GetWidth(),imgtmp.GetHeight() , 0,
                 GL_LUMINANCE,GL_UNSIGNED_BYTE, imgtmp.GetImageData());
  else {
    BIASERR("Can not handle texture with "<<imgtmp.GetChannelCount()
            <<" channels");
    return -1;
  }
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  // GL_NEAREST disables filtering and thus results in exactly the same image
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, MagFilter_);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, MinFilter_);

  maxtexcoordX = float(ImgWidth_)/float(img.GetWidth());
  maxtexcoordY = float(ImgHeight_)/float(img.GetHeight());
//   cout <<"ImgSize: "<<ImgWidth_<<" x "<<ImgHeight_<<endl;
//   cout <<"Padded ImgSize: "<<img.GetWidth()<<" x "<<img.GetHeight()<<endl;
//   cout <<"maxtexcoord: "<<maxtexcoordX<<" x "<<maxtexcoordY<<endl;
  TexCoord_[0][0] = 0.0;
  TexCoord_[0][1] = 0.0;

  TexCoord_[1][0] = maxtexcoordX;
  TexCoord_[1][1] = 0.0;

  TexCoord_[2][0] = maxtexcoordX;
  TexCoord_[2][1] = maxtexcoordY ;

  TexCoord_[3][0] = 0.0;
  TexCoord_[3][1] = maxtexcoordY;

//   for (unsigned int i=0;i<4;i++)
//     cout <<"TexCoord["<<i<<"]: "<<TexCoord_[i]<<endl;

  IsInitialized_ = true;
  return 0;
}





void SceneBGImage::
Draw()
{
  //  CALLINFO
  if (!IsInitialized_) {
    BIASERR("BGScene not initialized");
    return;
  }

  glPushAttrib(GL_DEPTH_BUFFER_BIT | GL_TEXTURE_BIT);

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();

  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();

  glDepthFunc(GL_LEQUAL);

  /* Specification and reference agree in description of glOrtho:
   * give distances of z clipping planes to eye point here. Will
   * mirror distance value, because the virtual camera is looking into
   * direction of decreasing z-coordinates, hence positive z-Clipping plane
   * distances will manifest into clipping planes lying at negative z-values
   * in the scene! (Reason: Negative vertex coordinates have to be
   * mapped to the z-values interval of [0,1] in the end. Projection matrix
   * together with homogenization shall map to normalized device coords. No
   * mirroring is done during ndc to window-coord mapping.
   * (see OpenGL Specification 2.0, p.40ff))
   *
   * Briefly: specify positive value n, f -> get planes lying at -n, -f,
   * while camera is looking in direction of -z!
   *
   * refer to glOrtho reference or OpenGL Specification 2.0, p.45f. */
  glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);

  glDepthMask(GL_FALSE);

  glEnable(GL_TEXTURE_2D);
  glEnable(GL_BLEND);
  glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);

  glBindTexture(GL_TEXTURE_2D,BackgroundImageTex_);

  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  glDisable(GL_TEXTURE_GEN_S);
  glDisable(GL_TEXTURE_GEN_T);
  glMatrixMode(GL_TEXTURE);
  glLoadIdentity();

  glBegin(GL_QUADS);
  glTexCoord2fv(TexCoord_[0].GetData());
  glVertex3f(-1.0, 1.0, -1.0);
  glTexCoord2fv(TexCoord_[3].GetData());
  glVertex3f(-1.0, -1.0, -1.0);
  glTexCoord2fv(TexCoord_[2].GetData());
  glVertex3f(1.0, -1.0, -1.0);
  glTexCoord2fv(TexCoord_[1].GetData());
  glVertex3f(1.0, 1.0, -1.0);
  glEnd();

  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  glPopAttrib(); //GL_DEPTH_BUFFER_BIT | GL_TEXTURE_BIT
  glDisable(GL_BLEND);
}


void SceneBGImage::
SetMinMagFilter(int MinFilter,int MagFilter)
{
  MagFilter_ = MagFilter;
  MinFilter_ = MinFilter;
  if (IsInitialized_) {
    glBindTexture(GL_TEXTURE_2D,BackgroundImageTex_);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, MagFilter_);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, MinFilter_);
  }
}