GLProjectionParametersBase.cpp

#include "GLProjectionParametersBase.hh"
#ifdef __APPLE__
# include <OpenGL/glu.h>
#else // __APPLE_
# include <GL/glu.h>
#endif // __APPLE__
#include <OpenGLFramework/Base/glfScreen.hh>
#include <OpenGLFramework/Base/glfException.hh>
#include <GLviewer/OutputAttachments/OutputWowDisplay.hh>
#include <GLviewer/OutputAttachments/OutputHaze.hh>
#include <GLviewer/OutputAttachments/OutputWowDisplay2.hh>
#include <GLviewer/OutputAttachments/OutputUnderwater.hh>
#include <GLviewer/OutputAttachments/OutputLensDistortion.hh>
#include <Utils/GlewInitWrapper.hh>
#include <Base/Common/CompareFloatingPoint.hh>
using namespace BIAS;
using namespace std;

#define RAD_TO_DEG 57.29577951
//#define DEBUG_RESCALE

int GLProjectionParametersBase::instanceCounter = -1;

GLProjectionParametersBase::
GLProjectionParametersBase(): Debug()
{
  //instances
  instanceCounter++;
  instanceNum_ = instanceCounter;
  //bools
  callInitBeforeDraw_          =true;
  subtractFromBackgroundImage_ =false;
  useStencilBuffer_            =false;
  offscreenRenderingEnabled_   =false;

  outputAttachmentIdentifiers_.clear();
  outputAttachmentOptions_.clear();
  outputAttachments_.clear();
  
  currentRenderTarget_      = NULL;
  backgroundImageScene_     = NULL;
  //others
  ClearColor_[0]=ClearColor_[1]=ClearColor_[2]=ClearColor_[3]=0.0;
  ClearDepth_=1.0;
  //init func
  InitRaw_();
}

GLProjectionParametersBase::
~GLProjectionParametersBase()
{}


void GLProjectionParametersBase::
SetDebugLevel(const long int lv)
{
  Debug::SetDebugLevel(lv);
}


void GLProjectionParametersBase::
AddDebugLevel(const long int lv)
{
  Debug::AddDebugLevel(lv);
#ifdef BIAS_HAVE_CLASS_DISTORTIONRENDERING
  distortionRendering_.AddDebugLevel(lv);
#endif
#ifdef BIAS_HAVE_CLASS_FISHEYERENDERING
  fisheyeRendering_.AddDebugLevel(lv);
#endif
}

void GLProjectionParametersBase::
Assign(BIAS::ProjectionParametersBase& p){
  SetExtrinsics(p.GetC(),p.GetR());
  SetIntrinsics(&p);
}

void GLProjectionParametersBase::
SetIntrinsics(BIAS::ProjectionParametersBase *p){
  BIASERR("Call derived class!");
}

void GLProjectionParametersBase::
Set(BIAS::ProjectionParametersBase *p){
  BIASERR("Call derived class!");
}

void GLProjectionParametersBase::
SetRenderTarget(glfRenderTarget* RT)
{
  if(RT == NULL)
  {
    currentRenderTarget_ = &(glfScreen::GetInstance());
  }
  else
  {
    currentRenderTarget_ = RT;
  }
}

BIAS::glfRenderTarget* GLProjectionParametersBase::
GetRenderTarget()
{
  // choose render target: offscreen rendering overrides 'currentRenderTarget_'
  BIAS::glfRenderTarget* renderTarget = currentRenderTarget_;

  #ifdef BIAS_HAVE_CLASS_OFFSCREENRENDERING
  if (offscreenRenderingEnabled_) {
    renderTarget = offscreenRendering_.GetFBO();
  }
  #endif

  return renderTarget;
}


void GLProjectionParametersBase::
InitRaw_()
{
  zNear_ = 0.1;
  zFar_ = 3000.0;
  SetToUnknownState_();
  currentRenderTarget_ = &glfScreen::GetInstance();
}

void GLProjectionParametersBase::
SetToUnknownState_()
{
  FirstRenderingPassFinished_ = false;
  drawingUpperLeft_[0] = 0;
  drawingUpperLeft_[1] = 0;
  lastDrawingUpperLeft_[0] = 0;
  lastDrawingUpperLeft_[1] = 0;

  for(unsigned int i=0; i<3; i++) {
    lastUsedGLViewport_[i] = 0;
    lastFullGLViewport_[i] = 0;
  }
  subtractFromBackgroundImage_ = false;
  AutoViewingMatchBehaviour_ = AutoRescaleParams;
}


void  GLProjectionParametersBase::
SetGLCameraToLocal() {
  float m[16] =
    {1.0,  0.0,  0.0, 0.0,
     0.0, -1.0,  0.0, 0.0,
     0.0,  0.0, -1.0, 0.0,
     0.0,  0.0,  0.0, 1.0 };
  glMatrixMode(GL_MODELVIEW);
  glLoadMatrixf(m);
}


int GLProjectionParametersBase::
Draw(std::vector<SceneBase *>& scenes,
     SceneBGImage* backgroundImageScene,
     BIAS::glfFramebufferObject* theTarget )
{
 { GLenum err = glGetError(); if (err != GL_NO_ERROR) { BIASERR("My OpenGL Error 3: " << gluErrorString(err)); } }

  unsigned int imgWidth, imgHeight;


  //backup pointer to backgroundscene
  backgroundImageScene_ = backgroundImageScene;

  //set render target
  if(theTarget != NULL) SetRenderTarget(theTarget);

    if(ExtrinsicStateChanged_ && (UpdateGLModelViewMatrix_()!=0)) {
    BIASERR("failure updating ModelViewMatrix\n");
    return -1;
  }

  GetMyselfAsProjectionParameterBase()->GetImageSize(imgWidth, imgHeight);
  BIASDOUT(GLP_VIEWPORT,"Size from ProjectionParameters: "<<imgWidth<<"x"<<imgHeight);
  BIASASSERT(imgWidth!=0 && imgHeight!=0);

#ifdef BIAS_HAVE_CLASS_OFFSCREENRENDERING
  if(offscreenRenderingEnabled_) {   
    SetGLViewport_(0,0,imgWidth,imgHeight);
    BIASDOUT(GLP_VIEWPORT,"Setting viewport for offscreen to: "<<imgWidth<<"x"<<imgHeight);
  }
  try{
    if(offscreenRenderingEnabled_ && !offscreenRendering_.IsInitialized()) {
      unsigned int imgWidth, imgHeight;
      GetMyselfAsProjectionParameterBase()->GetImageSize(imgWidth, imgHeight);
      BIASDOUT(GLP_VIEWPORT,"Imagesize in BeginDraw:"<<imgWidth<<"x"<<imgHeight);
      if(offscreenRendering_.Init(imgWidth, imgHeight)!=0) {
        BIASERR("offscreen rendering could not be initialized\n");
        return -1;
      }
    }
  }
  catch (glfException& e){
    BIASERR("GL Error in Offscreenrender initialization in Draw() : " << e.GetMessageString());
    return -1;
  }
#endif // BIAS_HAVE_CLASS_OFFSCREENRENDERING
  int viewport[4];  
  GetGLViewport_(viewport[0],viewport[1],viewport[2],viewport[3]);
  
  BIASDOUT(GLP_VIEWPORT,"Getting Viewport for control in Draw:"<<viewport[0]
           <<","<<viewport[1]<<","<<viewport[2]<<","<<viewport[3]);

  // this is necessary, otherwise the modelview matrix is not set correctly
  if(UpdateGLProjectionMatrix_(0, 0, imgWidth, imgHeight)!=0) {
    BIASERR("error updating Projection matrix!");
    return -1;
  }
  //prepare attachments
  PrepareOutputAttachments_();
  
  //call either  Draw_() or DrawWithMatchedParamsAndViewport_(...)
  if(imgWidth == (unsigned)viewport[2] && 
     imgHeight == (unsigned)viewport[3] &&
     AutoViewingMatchBehaviour_ != AdaptToCroppedImage)
    {
      lastDrawingUpperLeft_[0] = viewport[0]; //why upperleft? isn't this the lower left?
      lastDrawingUpperLeft_[1] = viewport[1];

      if (outputAttachments_.empty()) {
        return Draw_(scenes);
      } else {
        int ret = 0;
        for (unsigned int i=0;i<outputAttachments_.size();i++) {
          ret = Draw_(scenes, outputAttachments_[i]->GetOutputFBO() );
          if (ret!=0)
            return ret;
        }
      }
    }
  else{
    try{
      return DrawWithMatchedParamsAndViewport_(viewport,
                                               imgWidth, imgHeight,
                                               scenes);
    }catch (glfException& e){
      BIASERR("GL Error in Draw() : " << e.GetMessageString());
      return -1;
    }
  }
  return 0;
}

int GLProjectionParametersBase::
GetGLViewport_(int &lowerleftx,int &lowerlefty, 
                           int &sizex,int &sizey){
  int viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);
  lowerleftx = viewport[0];
  lowerlefty = viewport[1];
  sizex = viewport[2];
  sizey = viewport[3];    
  return 0;
}

int GLProjectionParametersBase::
SetGLViewport_(int lowerleftx,int lowerlefty,
                           int sizex,int sizey){
    glViewport(lowerleftx,lowerlefty,sizex,sizey);
    lastUsedGLViewport_[0] =  lowerleftx;
    lastUsedGLViewport_[1] =  lowerlefty;
    lastUsedGLViewport_[2] =  sizex;
    lastUsedGLViewport_[3] =  sizey;        
    return 0;
}

/*
 * Implementing in this method:
 * (mainly about lastUsedViewport_) Draw_ will store
 * the found viewport set in GL into the member lastUsedViewport_.
 * This should help speeding up decisions in this method.
 * Moreover its necessary to determine the valid window part for
 * user interaction and calculation of image to viewport coordinates.
 * If changing the viewport in this method it should be reset to the
 * argument values before return.
 */
int GLProjectionParametersBase::
DrawWithMatchedParamsAndViewport_(int viewport[4],
                                  int imageWidth,int imageHeight,
                                  std::vector<SceneBase*>& scenes)
{
  int res = 0;
  /*
  cout << "entering GLPPB::DrawWithMatchedParamsAndViewport_() with image ("
       << imageWidth << " x " << imageHeight << ")" << endl;
  */
  switch(AutoViewingMatchBehaviour_)
    {
    case Deny:
      BIASERR("viewport dimensions do not match parameters!"<<endl
              <<"image="<<imageWidth<<"x"<<imageHeight<<"    viewport="
              <<viewport[0]<<";"<<viewport[1]<<" -> "
              <<viewport[2]<<";"<<viewport[3]<<endl);
      break;
    case AutoRescaleParams:
    {
        lastDrawingUpperLeft_[0] = 0;
        lastDrawingUpperLeft_[1] = 0;
        if(lastFullGLViewport_[2] == viewport[2] &&
                lastFullGLViewport_[3] == viewport[3] &&
                lastUsedGLViewport_[2] > 0 &&
                lastUsedGLViewport_[3] > 0 )
        {
            SetGLViewport_(lastUsedGLViewport_[0],lastUsedGLViewport_[1],
                    lastUsedGLViewport_[2],lastUsedGLViewport_[3]);
            
            res = Draw_(scenes);
#ifdef DEBUG_RESCALE
            cout<<"Same Viewport:"<<lastUsedGLViewport_[0]<<","<<
            lastUsedGLViewport_[1]<<","<<lastUsedGLViewport_[2]<<","<<
            lastUsedGLViewport_[3]<<endl;
#endif
        }
        else
        {
            for(unsigned int i=0; i<4; i++)
                lastFullGLViewport_[i] = viewport[i];

#ifdef DEBUG_RESCALE
            cout<<"new Viewport:"<<viewport[0]<<","<<
            viewport[1]<<","<<viewport[2]<<","<<
            viewport[3]<<endl;
#endif

            //determine whether enlarging or shrinking the image
            //in this case scale greater one means enlarging the image
            double decisionScaleWidth = ((double)viewport[0] - (double)viewport[2]) / (double)imageWidth;
            double decisionScaleHeight = ((double)viewport[1]- (double)viewport[3]) / (double)imageHeight;
            double decisionScale;
            if(decisionScaleWidth<decisionScaleHeight)
                decisionScale = decisionScaleWidth;
            else
                decisionScale = decisionScaleHeight;

            if(Equal(decisionScale,1.0))
            {
                //documentation!! What does it do??
                SetGLViewport_(viewport[0], viewport[1]+(viewport[3]-imageHeight),
                        imageWidth, imageHeight);
                res = Draw_(scenes);
                SetGLViewport_(viewport[0], viewport[1],viewport[2], viewport[3]);
            }
            else
            {
                unsigned int newImageWidth=0, newImageHeight=0;
                int ggT = imageWidth;
                int b = imageHeight;
                int r;
                while (b > 0)
                {
                    r = ggT % b;
                    ggT = b;
                    b = r;
                }

                if(ggT == 1 && decisionScale < 1)
                {
                    BIASERR("viewport too small for rescale");
                    return -1;
                }
                else
                {
                    int smallestImageWidth = imageWidth / ggT;
                    int smallestImageHeight = imageHeight / ggT;

                    decisionScaleWidth = (double)viewport[2]/(double)smallestImageWidth;
                    decisionScaleHeight= (double)viewport[3]/(double)smallestImageHeight;
                    if(decisionScaleWidth<decisionScaleHeight)
                        decisionScale = decisionScaleWidth;
                    else
                        decisionScale = decisionScaleHeight;
                    int flooredDecisionScale = (int)floor(decisionScale);
                    if(flooredDecisionScale == 1)
                    {
                        newImageWidth = smallestImageWidth;
                        newImageHeight = smallestImageHeight;
                    }
                    if(flooredDecisionScale > 1)
                    {
                        newImageWidth = (int) ((double)smallestImageWidth * flooredDecisionScale);/*decisionScale*/
                        newImageHeight = (int)((double)smallestImageHeight * flooredDecisionScale);/*decisionScale*/
                    }
                    if(flooredDecisionScale < 1)
                    {
                        BIASERR("this should never happen!");
                        return -100;
                    }
                    /*
                    if(decisionScale == 1.0)
                    {
                        newImageWidth = smallestImageWidth;
                        newImageHeight = smallestImageHeight;
                    }
                    if(decisionScale > 1)
                    {
                        newImageWidth = (int) ((double)smallestImageWidth * decisionScale);
                        newImageHeight = (int)((double)smallestImageHeight * decisionScale);
                    }
                    if(decisionScale < 1)
                    {
                        BIASERR("this should never happen!");
                        return -100;
                    }
                      */
                }//else ggT > 1

                // ratio < 1 means image has been enlarged
                double ratio = double(imageWidth)/ double(newImageWidth);
                GLProjectionParametersBase::Rescale(ratio); //sets intrinsicschanged = true;
                if(UpdateGLProjectionMatrix_(0, 0, newImageWidth, newImageHeight)!=0)
                {
                    BIASERR("UpdateGLProjectionMatrix_ failed");
                    return -1;
                }
                //unter linke ecke: viewport[0] und [1]
                SetGLViewport_(viewport[0], viewport[1]+(viewport[3]-newImageHeight),
                                                 newImageWidth, newImageHeight);
#ifdef DEBUG_RESCALE
                cout<<"setting the vp to: "<<viewport[0]<<" "
                <<viewport[1]+(viewport[3]-newImageHeight)<<" "
                <<newImageWidth<<" "<<newImageHeight<<endl;
#endif
                res = Draw_(scenes);
            }
        }
        break;
    }
    case AdaptToCroppedImage:

        if(lastFullGLViewport_[2] == viewport[2] &&
                lastFullGLViewport_[3] == viewport[3])
        {
            res = Draw_(scenes);
        }
        else
        {
            BIASWARN("AdaptToCroppedImage disabled on last Vision-N merge, reactivate if required!");
            //          double decisionScaleWidth =  (double)viewport[2] / (double)imageWidth;
            //           double decisionScaleHeight = (double)viewport[3] / (double)imageHeight;
            //           double decisionScale;

            //           if(decisionScaleWidth>decisionScaleHeight)
            //             decisionScale = 1.0/decisionScaleWidth;
            //           else
            //             decisionScale = 1.0/decisionScaleHeight;


            //           //force new image dimension (don't use rescale - it fails because of rounding errors)
            //           SetImageSize(viewport[2],viewport[3]);
            //           SetIdealImageSize(viewport[2],viewport[3]);
            //           //scale principal point
            //           double cx,cy;
            //           GetPrincipal(cx,cy);
            //           SetPrincipal(cx/decisionScale,cy/decisionScale);
            //           //scale focal length
            //           double f;
            //          //TODO adjust skew ...
            //          GetFocalLength(f);
            //          SetFocalLengthAndAspect(f/decisionScale,(double)viewport[2]/(double)viewport[3]);
            //          GLProjectionParametersBase::Rescale(1.0); //create new K

            //          for(unsigned int i=0; i<4; i++)
            //            lastFullGLViewport_[i] = viewport[i];

            //          SetGLViewport_(lastFullGLViewport_[0],
            //                     lastFullGLViewport_[1],
            //                     lastFullGLViewport_[2],
            //                     lastFullGLViewport_[3]);
            //          IntrinsicStateChanged_=true;
            //          informScenesOfChange_ = true;
            //          if (UpdateGLProjectionMatrix_(lastFullGLViewport_[0],
            //                                        lastFullGLViewport_[1],
            //                                        lastFullGLViewport_[2],
            //                                        lastFullGLViewport_[3])!=0) BIASABORT;
            //          InitShaders_();
            //          res = Draw_(scenes);
        }
        break;
    case AutoCutImage:
    {
        int visibleWidth = imageWidth - drawingUpperLeft_[0];
        int visibleHeight = imageHeight - drawingUpperLeft_[1];

        int newWidth, newHeight, newLLY;
        if(visibleWidth < viewport[2])
        {
            //viewport is bigger then image -> adapt viewport + move viewport
            newWidth = visibleWidth;
        }
        else
        {
            //viewport is smaller then image -> adapt image
            newWidth = viewport[2];
        }

        if(visibleHeight < viewport[3])
        {
            //viewport is bigger then image->adapt viewport
            newHeight = visibleHeight;
            newLLY = viewport[3] - visibleHeight;
        }
        else
        {
            //viewport is smaller then image -> adapt image
            newHeight = viewport[3];
            newLLY = viewport[1];
        }
        SetGLViewport_(viewport[0], newLLY,
                                 newWidth, newHeight);
        lastDrawingUpperLeft_[0] = drawingUpperLeft_[0];
        lastDrawingUpperLeft_[1] = drawingUpperLeft_[1];
        res = DrawPartOfImage_(drawingUpperLeft_[0],
                drawingUpperLeft_[1],
                newWidth, newHeight,
                scenes);
        SetGLViewport_(viewport[0], viewport[1],
                                       viewport[2], viewport[3]);
    } break;

    case AutoRescaleSimple:
    {
        lastDrawingUpperLeft_[0] = 0;
        lastDrawingUpperLeft_[1] = 0;

        if(lastFullGLViewport_[2] == viewport[2] &&
                lastFullGLViewport_[3] == viewport[3] &&
                lastUsedGLViewport_[2] > 0 && lastUsedGLViewport_[3] > 0 ) {
            /*
      cout<<"(ARS) same Viewport: "
          <<lastUsedGLViewport_[0]<<", "<<lastUsedGLViewport_[1]<<", "
          <<lastUsedGLViewport_[2]<<", "<<lastUsedGLViewport_[3]<<endl;
             */

            SetGLViewport_(lastUsedGLViewport_[0],lastUsedGLViewport_[1],
                               lastUsedGLViewport_[2],lastUsedGLViewport_[3]);


            res = Draw_(scenes);

        }
        else {
            /*
      cout<<"(ARS) new Viewport: "
          <<viewport[0]<<", "<<viewport[1]<<", "
          <<viewport[2]<<", "<<viewport[3]<<endl;
             */
            for(unsigned int i=0; i<4; i++) {
                lastFullGLViewport_[i] = viewport[i];
            }

            //determine whether enlarging or shrinking the image
            //in this case scale greater one means enlarging the image
            double decisionScaleWidth = (double)viewport[2] / (double)imageWidth;
            double decisionScaleHeight = (double)viewport[3] / (double)imageHeight;
            /*
      cout<<"\nGLPPB::DrawWithMatchedParamsAndViewport_():\n" << setprecision(10)
          << "\tdecisionScaleWidth = viewport[2] / imageWidth: " << decisionScaleWidth
          << " = " << viewport[2] << " / " << imageWidth << endl;
      cout<< setprecision(10)
          << "\tdecisionScaleHeight = viewport[3] / imageHeight: " << decisionScaleHeight
          << " = " << viewport[3] << " / " << imageHeight << endl;
             */
            double decisionScale;
            if(decisionScaleWidth<decisionScaleHeight)
                decisionScale = decisionScaleWidth;
            else
                decisionScale = decisionScaleHeight;

            if( Equal(decisionScale,1.0) ) {
                /*
        cout<<"\nGLPPB::DrawWithMatchedParamsAndViewport_(): no rescale" << setprecision(10)
        << "\n\tdecisionScale = " << decisionScale 
        << "\n\tviewport ("
        <<viewport[0]<<", "<<viewport[1]<<", "
        <<viewport[2]<<", "<<viewport[3]<<")"
        <<"\n\timage (" << imageWidth << " x " << imageHeight << ")" <<endl;
                 */
                SetGLViewport_(viewport[0], viewport[1]+(viewport[3]-imageHeight),
                        imageWidth, imageHeight);

                res = Draw_(scenes);

                SetGLViewport_(viewport[0], viewport[1],viewport[2], viewport[3]);
                /*
        cout << "drawing unscaled: setting vp to: "
         <<viewport[0]<<", "<<viewport[1]<<", "
         <<viewport[2]<<", "<<viewport[3]<<endl;
                 */
            }
            else { // !Equal(decisionScale,1.0)
                double tmpImageHeight, tmpImageWidth;
                tmpImageWidth = (double)imageWidth * decisionScale;
                tmpImageHeight = (double)imageHeight * decisionScale;
                double ratio = (double)imageWidth / tmpImageWidth;
                /*
        cout << "GLPPB::DrawWithMatchedParamsAndViewport_() rescale: "
         << "\n\tratio = " << ratio << ", decisionScale = " << decisionScale
         << "\n\timage (" << imageWidth << " x " << imageHeight << ")" 
         << "\n\tnew image (" << newImageWidth << " x " << newImageHeight << ")" << endl;
                 */
                GLProjectionParametersBase::Rescale(ratio); //sets intrinsicschanged = true;

                int newImageWidth = (int)rint(tmpImageWidth);
                int newImageHeight = (int)rint(tmpImageHeight);
                if( UpdateGLProjectionMatrix_( 0, 0, 
                        newImageWidth, newImageHeight) != 0 ) {
                    return -1;
                }
                //untere linke ecke: viewport[0] und [1]
                SetGLViewport_(viewport[0], viewport[1]+(viewport[3]-newImageHeight),
                                   newImageWidth, newImageHeight);
                /*
        cout<<"drawing scaled: setting vp to: "
        <<viewport[0]<<", "<<viewport[1]+(viewport[3]-newImageHeight)<<", "
        <<newImageWidth<<", "<<newImageHeight<<endl;
                 */
                res = Draw_(scenes);
            } // end if (Equal(decisionScale,1.0))
        }
        break;
    }
    case AutoSimplePerspectiveCam:
    {
        //BIASWARN("AutoSimplePerspectiveCam disabled on last Vision-N merge, reactivate if required!");
        //assuming simple perspective camera with principle point on image center
      ProjectionParametersPerspective* ppp
          = dynamic_cast<ProjectionParametersPerspective*>(GetMyselfAsProjectionParameterBase());

      if(ppp){

          for(unsigned int i=0; i<4; i++)
              lastFullGLViewport_[i] = viewport[i];

            /*double flength = ppp->GetFocalLength();
            double ysize = ppp->GetImageHeight();
            double normedImageSizeHalf = ysize/2.0;
            double angleDEG = 2.0*atan(normedImageSizeHalf/ppp->GetFocalLength());*/

            //TODO: Retrieve the FoV from the projection without degenerating
            // for now the FoV is fixed to 1.5
            ppp->SetSimplePerspective(1.5, viewport[2], viewport[3]);

            if(UpdateGLProjectionMatrix_(0,0, viewport[2],  viewport[3])!=0)
                return -1;
            lastDrawingUpperLeft_[0] = 0;
            lastDrawingUpperLeft_[1] = 0;

            SetGLViewport_(0,0, viewport[2], viewport[3]);
            
            Draw_(scenes);
        }
        else 
            BIASWARN("AutoSimplePerspectiveCam only for perspective cameras, guess why?!");
         
    }
    break;
    default: cerr<<"unknown matching behaviour\n"; return -1; break;
    }
  return res;
}

int GLProjectionParametersBase::
DrawPartOfImage_(const unsigned int ulX,
                 const unsigned int ulY,
                 const unsigned int width,
                 const unsigned int height,
                 std::vector<SceneBase *> scenes)
{
  if(ExtrinsicStateChanged_)
    if(UpdateGLModelViewMatrix_()!=0)
      return -1;

  if(UpdateGLProjectionMatrix_(ulX, ulY, width, height)!=0)
    return -1;

#ifdef BIAS_DEBUG
  int viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);

  //image size and viewport resolution have to be the same
  if((int)width!=viewport[2] || (int)height!=viewport[3]) {
    cerr<<"viewport dimensions do not suffice!\n";
    return -1;
  }
#endif

  int res = Draw_(scenes);
  IntrinsicStateChanged_ = true;//Draw() must calc new projection matrix
  //the abstract parameters did not change so do not inform scenes!
  return res;
}


void GLProjectionParametersBase::
InitBeforeDraw_()
{
  GlewInitWrapper::GetInstance()->Init();
}

int GLProjectionParametersBase::
BeginDraw_(BIAS::glfFramebufferObject* theTarget)
{
#ifdef DEBUG_RESCALE  
  BIAS::Vector4<int> tmp;
  glGetIntegerv(GL_VIEWPORT, tmp.GetData());
  cout << "\nentering BeginDraw_(): GLViewport is " << tmp[0]
       << ", " << tmp[1]
       << ", " << tmp[2]
       << ", " << tmp[3] << endl;
  BIASASSERT(tmp[1] != 1);
#endif

  if(callInitBeforeDraw_) {
    try{
      InitBeforeDraw_(); // call glewInit() and offscreen render init
      callInitBeforeDraw_ = false;
    }
    catch (glfException& e){
      BIASERR("Error in InitBeforeDraw in BeginDraw_() : " << e.GetMessageString());
      return -1;
    }
  }

  //  bind render target
  glfRenderTarget* renderTarget;
  if (theTarget == NULL) {
    renderTarget = GetRenderTarget();
  }
  else{
    renderTarget = theTarget;
  }

  try{
    renderTarget->Bind();
    //added
    renderTarget->ClearColorBuffer(ClearColor_[0],ClearColor_[1],ClearColor_[2],ClearColor_[3]);
    renderTarget->ClearDepthBuffer(ClearDepth_);
    if(useStencilBuffer_) { 
      renderTarget->ClearStencilBuffer();
      //cout << "STENCIL USAGE IS ON!!!" << endl;
    }
  }
  catch (glfException& e){
    BIASERR("GL Error in BeginDraw_() : " << e.GetMessageString());
    //return -1;
  }
  //push attributes to the attribute stack
  glPushAttrib(GL_TRANSFORM_BIT | GL_ENABLE_BIT |
               GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

  //blending, enabled in RenderContextBase with AllowBlending(bool)
  if(glIsEnabled(GL_BLEND)) {
    glBlendEquationSeparate(GL_FUNC_ADD, GL_MAX);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  }

  //enable depth test
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LEQUAL);

  //enable writing into the depth buffer
  glDepthMask(GL_TRUE);

  //get glviewport and set to lastUsedGLViewport_
  GetGLViewport_(lastUsedGLViewport_[0],lastUsedGLViewport_[1],
        lastUsedGLViewport_[2],lastUsedGLViewport_[3]);
  
#ifdef DEBUG_RESCALE  
  cout << "BeginDraw_(): get GLViewport: " << lastUsedGLViewport_[0]
       << ", " << lastUsedGLViewport_[1]
       << ", " << lastUsedGLViewport_[2]
       << ", " << lastUsedGLViewport_[3] << endl;
#endif
  //if intrinsics chnaged update GLProjectionMatrix
  if(IntrinsicStateChanged_) {
    if (UpdateGLProjectionMatrix_(lastUsedGLViewport_[0],lastUsedGLViewport_[1],
                                  lastUsedGLViewport_[2],lastUsedGLViewport_[3])!=0)
      BIASERR("UpdateGLProjectionMatrix_ failed!");
    BIASABORT;
  }

  //projection and model view matrix
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadMatrixd(GLProjectionMatrix_.GetData());

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadMatrixd(GLModelViewMatrix_.GetData());

  if(useStencilBuffer_) glEnable(GL_STENCIL_TEST);

  return 0;
}

int GLProjectionParametersBase::
EndDraw_(BIAS::glfFramebufferObject* theTarget)
{
  GLF_THROW_ON_OPENGL_ERROR
#ifdef DEBUG_RESCALE  
  BIAS::Vector4<int> tmp;
  glGetIntegerv(GL_VIEWPORT, tmp.GetData());
  cout << "entering EndDraw_(): GLViewport is " << tmp[0]
       << ", " << tmp[1]
       << ", " << tmp[2]
       << ", " << tmp[3] << endl;
#endif
    GlewInitWrapper::GetInstance()->Init();
    //rendering set background image
  if(backgroundImageScene_ != NULL) {
      glEnable(GL_DEPTH_TEST);
#ifdef BIAS_HAVE_GLEW
      // checkin for GL1.4 fails on Intel GMA965, but blending works, so it would be wise 
      // to check for something more detailed 20091103 evers
      //if(GLEW_VERSION_1_4) {
        if(glIsEnabled(GL_BLEND) == GL_TRUE ) {
          if(!subtractFromBackgroundImage_) {
            BIASDOUT(GLP_ACTIVITY_HIGH, "rendering bg image !");

            glBlendEquationSeparate(GL_FUNC_ADD, GL_MAX);
            glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
            GLF_THROW_ON_OPENGL_ERROR
              }
          else {
            BIASDOUT(GLP_ACTIVITY_HIGH,
                     "preparing subtraction from background image !");
            glDisable(GL_DEPTH_TEST);
            glBlendEquationSeparate(GL_FUNC_SUBTRACT, GL_MAX);
            glBlendColor(0.5, 0.5, 0.5, 1.0);
            glBlendFunc(GL_ONE, GL_CONSTANT_COLOR);

            glMatrixMode(GL_PROJECTION);
            glPushMatrix();
            glLoadIdentity();
            glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            glLoadIdentity();
            glColor3f(0.5, 255.5, 0.5);
            glBegin(GL_QUADS);
            glVertex3f(-1, 1, -1);
            glVertex3f(1, 1, -1);
            glVertex3f(1, -1, -1);
            glVertex3f(-1, -1, -1);
            glEnd();

            glPopMatrix(); //model view
            glMatrixMode(GL_PROJECTION);
            glPopMatrix();

            glBlendEquationSeparate(GL_FUNC_ADD, GL_MAX);
            //      glBlendColor(0.5, 0.5, 0.5, 1.0);
            glBlendFunc(GL_CONSTANT_COLOR, GL_ONE);
          }
        }
        else {
          BIASDOUT(GLP_ACTIVITY_HIGH,"Blending Disabled: skipping blending/subtraction");
        }
    // }//is gl version 1.4 supported?
      /*else {
        BIASERR("Blending or difference image calculation is"
                " only available with gl version 1.4 or higher");
      }*/
#endif
      BIASDOUT(GLP_ACTIVITY_HIGH, "backgroundImageScene->Render() now !");
     glDisable(GL_STENCIL_TEST);
      backgroundImageScene_->Render();
    }

  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();

  //pop attribs set in BeginDraw_()
  //GL_TRANSFORM_BIT|GL_ENABLE_BIT|GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT
  glPopAttrib();

#ifdef BIAS_HAVE_CLASS_OFFSCREENRENDERING
  if(offscreenRenderingEnabled_)
    currentRenderTarget_->Bind();
#endif

  if (theTarget != NULL) {
    try{
      for (unsigned int i=0;i<outputAttachments_.size();i++)
        outputAttachments_[ i ]->Draw();
    }catch (glfException& e){
      BIASERR("GL Error in BeginDraw_() : " << e.GetMessageString());
      return -1;
    }
  }
#ifdef DEBUG_RESCALE  
  
  glGetIntegerv(GL_VIEWPORT, tmp.GetData());
  cout << "leaving EndDraw_(): GLViewport is " << tmp[0]
       << ", " << tmp[1]
       << ", " << tmp[2]
       << ", " << tmp[3] << endl << endl;
#endif
  GLF_THROW_ON_OPENGL_ERROR
  return 0;
}

int GLProjectionParametersBase::
UpdateGLModelViewMatrix_()
{
  if (!GetMyselfAsProjectionParameterBase()->PoseValid())
    {
      BIASERR("pose invalid?!");
      return -1;
    }

  //This have to be absolut values!
  RMatrix R; Vector3<double> C;
  GetExtrinsics(C,R);

  unsigned int i;
  for(i=0; i<3; i++) {
    R[i][1] = -R[i][1];
    R[i][2] = -R[i][2];
  }

  BIAS::Matrix4x4<double> newGLModelViewMatrix(R.Transpose(),
                                               (-1.0)*R.Transpose()*C);
  //see docu of GLModelViewMatrices_ in RenderProjection.hh
  GLModelViewMatrix_ = newGLModelViewMatrix.Transpose();

  ExtrinsicStateChanged_ = false;
  return 0;
}

bool GLProjectionParametersBase::
GetViewportCoordinates(int& x, int& y)
{
  //determine if x,y lie in viewport
  int xInLastViewport = x - lastUsedGLViewport_[0];
  int yInLastViewport = y - lastUsedGLViewport_[1];
  if(xInLastViewport<0 ||
     yInLastViewport<0 ||
     xInLastViewport>lastUsedGLViewport_[2] ||
     yInLastViewport>lastUsedGLViewport_[3])
    {
      cerr<<"argument point does not lie in last viewport\n";
      return false;
    }
  x = xInLastViewport;
  y = yInLastViewport;
  return true;
}

void GLProjectionParametersBase::
SetZClippingPlanes(float n, float f)
{
  SetNearClippingPlane(n);
  SetFarClippingPlane(f);
}

void GLProjectionParametersBase::
SetNearClippingPlane(float n)
{
  zNear_ = n;
  IntrinsicStateChanged_ = true;
}

void GLProjectionParametersBase::
SetFarClippingPlane(float f)
{
  zFar_ = f;
  IntrinsicStateChanged_ = true;
}


BIAS::HomgPoint3D GLProjectionParametersBase::
UnProject(const HomgPoint2D& p)
{
  double depth = 0.0; depth = GetDepth(p);
  if(depth==0.0) {
    BIASWARNONCE("Depth is 0!");
    Vector3<double> opticalray, pos;
    GetMyselfAsProjectionParameterBase()->UnProjectToRay(p, pos, opticalray);
    if(opticalray.NormL2()==0.0) {
      BIASWARNONCE("returned ray has zero length!");
      return HomgPoint3D(0,0,0,0);
    }
    return HomgPoint3D(opticalray[0], opticalray[1], opticalray[2], 0);
  }

  return GetMyselfAsProjectionParameterBase()->UnProjectToPoint(p, depth);
}

BIAS::HomgPoint3D GLProjectionParametersBase::
UnProject(const unsigned int x, const unsigned int y)
{
  //cout<<"[GLProjectionPArametersBase] Unproject "<<x<<","<<y<<endl;
  return UnProject(HomgPoint2D(x,y,1.0));
}

BIAS::HomgPoint3D GLProjectionParametersBase::
UnProject(BIAS::HomgPoint2D& point2D, double depth){

  return GetMyselfAsProjectionParameterBase()->UnProjectToPoint(point2D,depth);
}


BIAS::HomgPoint2D  GLProjectionParametersBase::
Project(HomgPoint3D &point){
  return  GetMyselfAsProjectionParameterBase()->Project(point);
}


int GLProjectionParametersBase::
GetExtrinsics(BIAS::Vector3<double>& C,
              BIAS::Vector3<double>& Up) const
{
  ProjectionParametersBase* pPPB = GetMyselfAsProjectionParameterBase();
  C = pPPB->GetC();
  RMatrix R = pPPB->GetR();
  for(unsigned int i=0; i<3; i++)
    Up[i] = -R[i][1];

  return 0;
}

int GLProjectionParametersBase::
GetExtrinsics(BIAS::Vector3<double>& C,
              BIAS::RMatrix& R) const
{
  BIAS::ProjectionParametersBase* pPPB=NULL;
  pPPB=GetMyselfAsProjectionParameterBase();
  if(pPPB == NULL) //this should never fail. xcept somebody made mistake...
    return -1;
  C = pPPB->GetC();
  R = pPPB->GetR();
  return 0;
}

 /* Implement functions from GLProjectionParametersInterface*/
int GLProjectionParametersBase::
SetExtrinsics(const BIAS::HomgPoint3D& C,
              const BIAS::Quaternion<double>& Q){
  BIAS::ProjectionParametersBase* pPPB=GetMyselfAsProjectionParameterBase();
  if(pPPB != NULL){
    ExtrinsicStateChanged_ = true;
    informScenesOfChange_  = true;
    Vector3<double> c(C[0],C[1],C[2]);
    pPPB->SetQC(Q,c);
    return 0;
  }
  else
    return -1;
}

int GLProjectionParametersBase::
SetExtrinsics(const BIAS::Vector3<double>& C,
              const BIAS::RMatrix& R)
{
  ProjectionParametersBase* pPPB = GetMyselfAsProjectionParametersBase();
  if(!pPPB) { cout<<"setextr failed"<<endl; return -1;}
  pPPB->SetC(C);
  pPPB->SetR(R);
  ExtrinsicStateChanged_ = true;
  informScenesOfChange_  = true;
  return 0;
}

  int GLProjectionParametersBase::
    SetExtrinsics(const BIAS::Vector3<double>& C,
                  const BIAS::Quaternion<double>& Q)
  {
    ProjectionParametersBase* pPPB = GetMyselfAsProjectionParameterBase();
    if(!pPPB) { cout<<"setextr failed"<<endl; return -1;}
    pPPB->SetC(C);
    pPPB->SetQ(Q);
    ExtrinsicStateChanged_ = true;
    informScenesOfChange_  = true;
    return 0;
  }

int GLProjectionParametersBase::
SetExtrinsics(const BIAS::HomgPoint3D& C,
              const BIAS::RMatrix& R)
{
  Vector3<double> tmp(C[0],C[1],C[2]);
  return SetExtrinsics(tmp,R);
}

int GLProjectionParametersBase::
SetExtrinsics(float eyex, float eyey, float eyez,
              float scenex, float sceney, float scenez,
              float upx, float upy, float upz)
{
  return SetExtrinsics( BIAS::Vector3<double>(eyex,eyey,eyez),
                        BIAS::Vector3<double>(scenex,sceney,scenez),
                        BIAS::Vector3<double>(upx,upy,upz));
}

int GLProjectionParametersBase::
SetExtrinsics(const BIAS::Vector3<double>& C,
              const BIAS::Vector3<double>& scenePoint,
              const BIAS::Vector3<double>& up)
{
  // cout <<"SetExtrinsics(C,ScenePoint,up)"<<endl;
  //   cout <<C<<","<<scenePoint<<","<<up<<endl;
  //calculate R and C
  RMatrix R;
  Vector3<double> A=(scenePoint-C);
  if(A.NormL2() == 0.0) {
    BIASERR("Camera center and scene point must not be the same!");
    C.Sub(Vector3<double>(0,0,-1),A);
    return -1;
  }
  A.Normalize();
  Vector3<double> V= -1.0*up;
  if(V.NormL2() == 0.0) {
    cerr<<"Up vector must not be the null vector \n";
    return -1;
  }
  V.Normalize();
  Vector3<double> H;
  V.CrossProduct(A,H);
  if(H.NormL2() == 0.0) {
    cerr<<"Up vector and viewing direction must not be parallel \n";
    return -1;
  }
  H.Normalize();
  //make sure the rotation matrix is orthonormal :
  A.CrossProduct(H,V);
  V.Normalize();

  for(unsigned int i=0; i<3; i++) {
    R[i][0] = H[i];
    R[i][1] = V[i];
    R[i][2] = A[i];
  }

  return SetExtrinsics(C, R);
}


/* has this  been deleted by CAU ?
void GLProjectionParametersBase::
SetR(const BIAS::RMatrixBase& R)
{
  Quaternion<double> Q;
  R.GetQuaternion(Q);
  SetQ(Q);
}
*/

double GLProjectionParametersBase::
GetDepth(const BIAS::HomgPoint2D& p)
{
  if(Less(p[0], 0.0) || Less(p[1], 0.0)) {
    BIASERR("point not in image");
    return 0.0;
  }

  unsigned int ul[2] = {(unsigned int)floor(p[0]), (unsigned int)floor(p[1])};
  double depthUL = GetDepth(ul[0], ul[1]);
  if(depthUL == 0.0) return 0.0;

  unsigned int ur[2] = {(unsigned int)ceil(p[0]), (unsigned int)floor(p[1])};
  double depthUR = GetDepth(ur[0], ur[1]);
  if(depthUR == 0.0) return 0.0;

  unsigned int ll[2] = {(unsigned int)floor(p[0]), (unsigned int)ceil(p[1])};
  double depthLL = GetDepth(ll[0], ll[1]);
  if(depthLL == 0.0) return 0.0;

  unsigned int lr[2] = {(unsigned int)ceil(p[0]), (unsigned int)ceil(p[1])};
  double depthLR = GetDepth(lr[0], lr[1]);
  if(depthLR == 0.0) return 0.0;

  double dx = p[0] - ul[0];
  double dy = p[1] - ul[1];

  return (depthUL +
          dy*(depthLL - depthUL) +
          dx*(depthUR - depthUL) +
          dy*dx*(depthUL + depthLR - depthLL - depthUR));
}


double GLProjectionParametersBase::
GetDepth(const unsigned int x, const unsigned int y)
{
  GetRenderTarget()->Bind();
  float depthRead = 0.0;
  GLint accessX = 0;
  GLint accessY = 0;
  accessX = GLint(lastUsedGLViewport_[0]+x);
  accessY = lastUsedGLViewport_[1]+ lastUsedGLViewport_[3]-1-y;
  glReadPixels(accessX,
               accessY,
               1, 1,
               GL_DEPTH_COMPONENT,
               GL_FLOAT, &depthRead);
  //  cout<<"[GLProjectionParametersBase] depthread (z):"<<depthRead<<endl;
  return Z2Depth_(x,y,depthRead);
}

void GLProjectionParametersBase::
ZBufferToDepthMap_(BIAS::Image<float>& depthMap)
{
  float* z = depthMap.GetImageData();
  //calculate distances on optical rays
  for ( int y=0; y<lastUsedGLViewport_[3]  ; y++)
    {
      for ( int x=0; x<lastUsedGLViewport_[2]; x++)
        {
          *z = Z2Depth_(x,y,*z);
          z++;
        }
    }
}


void GLProjectionParametersBase::
Rescale(float scale)
{
  Rescale_(scale);
  IntrinsicStateChanged_=true;

}

int GLProjectionParametersBase::
GetDepthMap(BIAS::Image<float>& depthMap, const float invalid)
{
  int res = GetZBuffer(depthMap);
  if(res!=0) return res;
  TranslateZToDepth(depthMap, invalid);
  return 0;
}


void GLProjectionParametersBase::
TranslateZToDepth(BIAS::Image<float>& depthMap,
                  const float invalid,
                  const bool flip) const {
  if(flip) depthMap.Flip();
  BIASASSERT(zFar_!=zNear_);
  float** z = depthMap.GetImageDataArray();
  //calculate distances on optical rays
  for ( unsigned  y=0; y<depthMap.GetHeight()  ; y++) {
    for ( unsigned  x=0; x<depthMap.GetWidth(); x++) {
      if (z[y][x] >= 1.0) z[y][x] = invalid;
      else if(z[y][x] != invalid){
        z[y][x]=Z2Depth_(x,y,z[y][x]);
      }
    }
  }
}


  /**
     \attention this is only valid for perspective cameras so far!
  */
void GLProjectionParametersBase::
TranslateZToMetricZ(BIAS::Image<float>& depthMap,
                    const float invalid,
                    const bool flip) const {
  if(flip) depthMap.Flip(); //is an in out variable!
  float** z = depthMap.GetImageDataArray();
  Vector3<double> ray;
  //calculate distances on optical rays
  for (unsigned int y=0; y<depthMap.GetHeight()  ; y++)
    {
      for (unsigned int x=0; x<depthMap.GetWidth(); x++)
        {
          if (z[y][x] >= 1.0) z[y][x] = invalid;
          else if(z[y][x] != invalid)
            {
              z[y][x] = zNear_*zFar_ / (zFar_ - (z[y][x])*(zFar_-zNear_));
            }
        }
    }
}

void GLProjectionParametersBase::
TranslateDepthToZ(BIAS::Image<float>& depthtoz,
                  const float invalid,
                  const bool flip) const
{
  if(flip) depthtoz.Flip();
  float** depth = depthtoz.GetImageDataArray();
  Vector3<double> ray, pos;
  //calculate distances on optical rays
  for ( int y=0; y<lastUsedGLViewport_[3]  ; y++)
    {
      for ( int x=0; x<lastUsedGLViewport_[2]; x++)
        {
          if(depth[y][x] != invalid)
            {
              //determine length of optical ray and assign to *z
              //if image is distorted will use undistortion
              GetMyselfAsProjectionParameterBase()->
              UnProjectToRay(HomgPoint2D(x,y,1.0), pos, ray);
              ray.Normalize();
              ray.MultIP(depth[y][x]);
              depth[y][x] = -((zNear_*zFar_)/ray[2]-zFar_)/(zFar_-zNear_);
            }
        }
    }
}


int GLProjectionParametersBase::
GetMetricZMap(BIAS::Image<float>& depthMap, const float invalid)
{
  int res = GetZBuffer(depthMap);
  if(res!=0) return res;
  TranslateZToMetricZ(depthMap, invalid);
  return 0;
}

int GLProjectionParametersBase::
GetZBuffer(BIAS::Image<float>& zBuffer)
{
  GetRenderTarget()->Bind();
  glFinish();
  int depthbits;
  glGetIntegerv(GL_DEPTH_BITS,&depthbits);
  if(depthbits==0)
    {
      cerr<<"no depth buffer available\n";
      return -1;
    }

  if (lastUsedGLViewport_[2] ==0 || lastUsedGLViewport_[3] ==0)
    {
      BIASERR("You never rendered, no screenshot now.");
      return -1;
    }

  if( (lastUsedGLViewport_[2] != (int)zBuffer.GetWidth())  ||
      (lastUsedGLViewport_[3] != (int)zBuffer.GetHeight()) ||
      zBuffer.GetChannelCount()!=1)
    {
      zBuffer.Release();
      zBuffer.Init(lastUsedGLViewport_[2],
                   lastUsedGLViewport_[3], 1);
    }
  //get z buffer
  glReadPixels(lastUsedGLViewport_[0],
               lastUsedGLViewport_[1],
               lastUsedGLViewport_[2],
               lastUsedGLViewport_[3],
               GL_DEPTH_COMPONENT,
               GL_FLOAT, zBuffer.GetImageData());
  // zBuffer.Flip();
  // set default render target.
  glfScreen::GetInstance().Bind();
  return 0;
}

void GLProjectionParametersBase::
ReadDepthBufferToTexture_(int texID, int width, int height)
{
  glBindTexture(GL_TEXTURE_2D, texID);
  glCopyTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT, 0,0, width, height, 0);
}

void GLProjectionParametersBase::
GetImage(BIAS::Image<unsigned char>& image)
{
  GetRenderTarget()->Bind();
  glFinish();
  int redbits, greenbits;
  glGetIntegerv(GL_RED_BITS, &redbits);
  glGetIntegerv(GL_GREEN_BITS, &greenbits);
  int colorType = image.GetChannelCount();
  if (lastUsedGLViewport_[2] ==0||lastUsedGLViewport_[3] ==0)
    {
      BIASERR("You never rendered, no screenshot now.");
      return;
    }

  if((int)image.GetWidth() != lastUsedGLViewport_[2] ||
     (int)image.GetHeight()!= lastUsedGLViewport_[3] ||
     (colorType == 1 && greenbits>0) ||
     (colorType == 3 && greenbits==0) ||
     (colorType != 1 && colorType != 3 ) )
    {
      if(greenbits>0)
        colorType = 3;
      else
        {
          if(redbits>0)
            colorType = 1;
          else
            {
              cerr<<"red framebuffer bits are zero!";
              BIASABORT;
            }
        }
      image.Release();
      image.Init(lastUsedGLViewport_[2],
                 lastUsedGLViewport_[3], colorType);
    }
  glFinish();
  // by default OpenGL assumes that rows are 4-byte-aligned,
  // which is wrong for BIAS::Image.
  glPixelStorei(GL_PACK_ALIGNMENT, 1);
  switch(colorType)
    {
    case 3:
      glReadPixels(lastUsedGLViewport_[0],
                   lastUsedGLViewport_[1],
                   lastUsedGLViewport_[2],
                   lastUsedGLViewport_[3],
                   GL_RGB,
                   GL_UNSIGNED_BYTE, image.GetImageData());
      break;
    case 1:
      glReadPixels(lastUsedGLViewport_[0],
                   lastUsedGLViewport_[1],
                   lastUsedGLViewport_[2],
                   lastUsedGLViewport_[3],
                   GL_RED,
                   GL_UNSIGNED_BYTE, image.GetImageData());
      break;
    }

  int err;
  if((err=glGetError()) != GL_NO_ERROR)
    cerr<<"Error getting image "<<gluErrorString(err)<<endl;
  image.Flip();

  glfScreen::GetInstance().Bind();
}

void GLProjectionParametersBase::
GetGreyImage(BIAS::Image<unsigned char>& image)
{
  GetRenderTarget()->Bind();
  int redbits, greenbits;
  glGetIntegerv(GL_RED_BITS, &redbits);
  glGetIntegerv(GL_GREEN_BITS, &greenbits);

  int colorType = image.GetChannelCount();
  if (lastUsedGLViewport_[2] ==0
      ||lastUsedGLViewport_[3] ==0)
    {
      BIASERR("You never rendered, no screenshot now.");
      return;
    }

  if((int)image.GetWidth() != lastUsedGLViewport_[2] ||
     (int)image.GetHeight() != lastUsedGLViewport_[3] ||
     (colorType != 1) )
    {
      if(!image.IsEmpty()) image.Release();
      image.Init(lastUsedGLViewport_[2],
                 lastUsedGLViewport_[3], 1);
    }


  //wait till all gl stuff is done
  glFinish();

  //decision made by gl color type
  if(greenbits>0)
    colorType = 3;
  else
    if(redbits>0)
      colorType = 1;
    else
      {
        BIASERR("red framebuffer bits are zero!\n");
        BIASABORT;
      }

  switch(colorType)
    {
    case 3:
      glPushAttrib(GL_PIXEL_MODE_BIT);
      glPixelTransferf(GL_RED_SCALE, 0.299);
      glPixelTransferf(GL_GREEN_SCALE, 0.587);
      glPixelTransferf(GL_BLUE_SCALE, 0.114);
      glReadPixels(lastUsedGLViewport_[0],
                   lastUsedGLViewport_[1],
                   lastUsedGLViewport_[2],
                   lastUsedGLViewport_[3],
                   GL_LUMINANCE,
                   GL_UNSIGNED_BYTE, image.GetImageData());
      glPopAttrib(); //GL_PIXEL_MODE_BIT
      break;
    case 1:
      glReadPixels(lastUsedGLViewport_[0],
                   lastUsedGLViewport_[1],
                   lastUsedGLViewport_[2],
                   lastUsedGLViewport_[3],
                   GL_RED,
                   GL_UNSIGNED_BYTE, image.GetImageData());
      break;
    }

  if(glGetError() != GL_NO_ERROR)
    cerr<<"Error getting image "<<gluErrorString(glGetError())<<endl;

  image.Flip();

  // set default render target.
  glfScreen::GetInstance().Bind();
}

void GLProjectionParametersBase::
ForceSceneUpdate()
{
  informScenesOfChange_= true;
}


void GLProjectionParametersBase::
SwitchToOffscreenRendering(bool offscreen){

  // BIASDOUT(GLP_ACTIVITY_BASIC,"Switching Instance:"<<instanceNum_<<" to offscreen");
#ifndef BIAS_HAVE_CLASS_OFFSCREENRENDERING
  if(offscreen) {
    cerr<<"offscreen rendering cannot be activated due to missing or "<<
      "inactive GLEW/GL/CG features!\n";
  }
  offscreenRenderingEnabled_=false;
#else
  offscreenRenderingEnabled_=offscreen;
  AutoViewingMatchBehaviour_ = Deny;
#endif
}

void GLProjectionParametersBase::AppendOutputAttachment(int type, std::vector<int> args) {
  if (!outputAttachments_.empty()) {
    BIASERR("adding output attachments after first call to draw not supported");
    return;
  }
  if (type == GLProjectionOutputAttachment::LensDistortion) {
    outputAttachmentIdentifiers_.push_front(type);
    outputAttachmentOptions_.push_front(args);
  } else {
    outputAttachmentIdentifiers_.push_back(type);
    outputAttachmentOptions_.push_back(args);
  }
}

// workaround for underwater needing to change parameters from outside, fkellner
GLProjectionOutputAttachment *GLProjectionParametersBase::GetAttachmentByType(int type) {
  for (int i=0;i<int(outputAttachmentIdentifiers_.size());i++) {
    if (outputAttachmentIdentifiers_[i] == type) {
      return outputAttachments_[i];
    }
  }
  return NULL;
}

void GLProjectionParametersBase::
PrepareOutputAttachments_() {
  if ( outputAttachments_.empty() && !outputAttachmentIdentifiers_.empty()) {
    // attach extra out
    outputAttachments_.resize( outputAttachmentIdentifiers_.size() );
    
    for (int i=int(outputAttachmentIdentifiers_.size())-1;i>=0;i--) {
      
      BIAS::glfRenderTarget *attachmentTarget;
      if (i == int(outputAttachmentIdentifiers_.size())-1) { // last one renders to screen
        attachmentTarget = GetRenderTarget();
      } else {
        attachmentTarget = outputAttachments_[i+1]->GetOutputFBO();
      }
      
      switch (outputAttachmentIdentifiers_[i]) {
      case GLProjectionOutputAttachment::WoWVX:
        if (outputAttachmentOptions_[i].size()!=2) {
          outputAttachments_[i] = new OutputWowDisplay(attachmentTarget);
        }
        else {
          outputAttachments_[i] = new OutputWowDisplay(attachmentTarget,
                                                   outputAttachmentOptions_[i][0],
                                                   outputAttachmentOptions_[i][1]);
        }
        BIASDOUT(GLP_ACTIVITY_BASIC,"Adding output attachment: WoWVX");
        break;
      case GLProjectionOutputAttachment::Haze:
        BIASDOUT(GLP_ACTIVITY_BASIC,"Adding output attachment: Haze");
        outputAttachments_[i] = new OutputHaze(attachmentTarget);
        break;
      case GLProjectionOutputAttachment::WoWVX2:
        BIASDOUT(GLP_ACTIVITY_BASIC,"Adding output attachment: WoWVX2");
        outputAttachments_[i] = new OutputWowDisplay2(attachmentTarget);
        break;
      case GLProjectionOutputAttachment::Underwater:
        BIASDOUT(GLP_ACTIVITY_BASIC,"Adding output attachment: Underwater");
        outputAttachments_[i] = new OutputUnderwater(attachmentTarget);
        break;
      case GLProjectionOutputAttachment::LensDistortion:
        BIASDOUT(GLP_ACTIVITY_BASIC,"Adding output attachment: Lens Distortion");
        outputAttachments_[i] = new OutputLensDistortion(attachmentTarget);
        dynamic_cast<OutputLensDistortion*>(outputAttachments_[i])->CreateLookupTable(this->GetMyselfAsProjectionParametersBase());
        break;
      default:
        BIASERR("Unknown Output Attachment, bailing out..");
        break;
      }
      outputAttachments_[i]->SetClearColor(ClearColor_);
    }
  }
}