ExamplePlainPerPixelProcessingTemporal.cpp

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

 Copyright (C) 2003-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
 */

/**
   @example ExamplePlainPerPixelProcessing.cpp
   @relates PlainPerPixelProcessing
   @brief Example for using the PlainPerPixelProcessing on the GPU
   @ingroup g_examples
   @ingroup g_openglframework
   @author MIP
*/

#include <iostream>

#include <OpenGLFramework/Base/glfFramebufferObject.hh>
#include <OpenGLFramework/SpecializedBatches/PlainPerPixelProcessing.hh>
#include <OpenGLFramework/RenderingContext/glfPBuffer.hh>

#include <Utils/Param.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/Image/Image.hh>
#include <Utils/IOUtils.hh>
#include <Base/Common/FileHandling.hh>

#include <list>
#include <vector>

using namespace BIAS;
using namespace std;



bool InitTemporalWindow(const vector<string>& filenames,
                        int halfWinSize,
                        int& firstValidIndex, int& lastValidIndex,
                        list<glfTexture2D*>& textureList);
bool ShiftWindow(const vector<string>& filenames,
                 int currentIndex,
                 list<glfTexture2D*>& textureList);

void ClearList(list<glfTexture2D*>& textureList);


int main(int argc, char* argv[]) {

  Param params(true);

  string* shaderFile = params.AddParamString("shader", "shader to be loaded");
  string* outputPrefix = params.AddParamString("outputPrefix", "", "", 'o');
  string* inputFileNameList = params.AddParamString("inputFileNameList",
                                                    "", "", 'i');

  int* temporalWindowHalfSize =
    params.AddParamInt("tempHW", "half win size of the temporal window", 0, 0);


  if(!IOUtils::ParseCommandLineEvalHelp(params, argc, argv)) {
    return 0;
  }


  if(inputFileNameList->size() == 0 ) {
    BIASERR("some input image list is required!");
  }

  vector<string> filenames;
  if(Param::ParseListFile(*inputFileNameList, filenames)!=0){
    BIASERR("error parsing image list!");
    return -1;
  }

  //check if enough images are present and preload the first window
  // information



  list<glfTexture2D*> textureList;
  glfPBuffer pbuffer;
  try {

    glfRenderingContextConfig cfg;
    cfg.width         = 5;
    cfg.height        = 5;
    cfg.doubleBuffer  = 0;
    cfg.redSize       = 8;
    cfg.greenSize     = 8;
    cfg.blueSize      = 8;
    cfg.alphaSize     = 0;
    cfg.depthSize     = 24;
    cfg.stencilSize   = 0;

    pbuffer.Init(cfg);



    int firstValidIndex, lastValidIndex;


    if(! InitTemporalWindow(filenames,
                            *temporalWindowHalfSize,
                            firstValidIndex, lastValidIndex,
                            textureList) ) {
      throw -1;
    }

    unsigned int width = textureList.front()->GetWidth();
    unsigned int height = textureList.front()->GetHeight();

    glfTexture2D outputTexture;
    outputTexture.Create();
    outputTexture.Set();
    outputTexture.Allocate(width, height, GL_RGB);

    glfFramebufferObject fbo;
    fbo.Create();
    fbo.AttachTexture(outputTexture, GL_COLOR_ATTACHMENT0_EXT);
    fbo.CheckComplete();
    fbo.ClearColorBuffer(0.0, 1.0, 1.0, 0.0);


    PlainPerPixelProcessing gpuProcess(true);

    gpuProcess.SetRenderTarget(&fbo);
    gpuProcess.SetOutputSize(width, height);
    gpuProcess.SetFragmentShaderFromFile(*shaderFile);

    Image<unsigned char> outputImage;

    int i = firstValidIndex;
    do {
      //keep in mind the first window has been loaded already
      gpuProcess.SetTextures(textureList);
      gpuProcess.Execute();
      outputTexture.CopyToImage(outputImage);
      string path, base, suffix;
      FileHandling::SplitName(filenames[i], path, base, suffix);
      ImageIO::Save(path+(*outputPrefix)+base+suffix, outputImage);
      cout<<" -> "<< filenames[i] <<endl;
      i++;
      if(!ShiftWindow(filenames, i, textureList) )
        throw -1;


    } while(i<lastValidIndex);


    ClearList(textureList);

  }
  catch (glfException& e) {
    std::cout << "Error: " << e.GetMessageString() << std::endl;
    ClearList(textureList);
    pbuffer.Destroy();
    return -1;
  }
  catch (...) {
    ClearList(textureList);
    pbuffer.Destroy();
    return -1;
  }


  pbuffer.Destroy();


  return 0;
}

/** Do not call witout proper GL Context.
**/

bool InitTemporalWindow(const vector<string>& filenames,
                        int halfWinSize,
                        int& firstValidIndex, int& lastValidIndex,
                        list<glfTexture2D*>& textureList)
/*,
                                                         list<glfTexture2D*>& texturePtList) */
{
  const int winElements = halfWinSize*2+1;
  const int allElements = static_cast<int>(filenames.size());
  if( winElements > allElements ) {
    BIASERR("temporal window and number of filenames do not fit!");
    return false;
  }
  firstValidIndex = halfWinSize;//zero based indexing
  lastValidIndex  = allElements - 1 - halfWinSize;



  Image<unsigned char> tmpImg;
  for( int i=0; i<winElements; i++) {
    if(ImageIO::Load(filenames[i], tmpImg) != 0) {
      BIASERR("error loadin image "<<filenames[i]);
      return false;
    }
    textureList.push_front(new glfTexture2D);
    textureList.front()->Create();
    textureList.front()->Set();
    textureList.front()->UploadImage(tmpImg);

  }

  return true;
}

bool ShiftWindow(const vector<string>& filenames,
                 int currentIndex,
                 list<glfTexture2D*>& textureList)
{
  Image<unsigned char> tmpImg;
  if(ImageIO::Load(filenames[currentIndex], tmpImg) != 0) {
    BIASERR("error loadin image "<<filenames[currentIndex]);
    return false;
  }

;
  textureList.push_front(new glfTexture2D);
  textureList.front()->Create();
  textureList.front()->Set();
  textureList.front()->UploadImage(tmpImg);
  delete textureList.back();
  textureList.pop_back();

  return true;
}

void ClearList(list<glfTexture2D*>& textureList) {
  list<glfTexture2D*>::iterator it=textureList.begin();
  for(;it!=textureList.end(); it++) {
    delete (*it);
  }
}