exampleDebayerCL.cpp

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

Copyright (C) 2003, 2004    (see file CONTACTS 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 <Utils/Param.hh>
#include <Utils/IOUtils.hh>
#include <Base/Image/Image.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/Image/ImageConvert.hh>
#include <OpenCLFramework/clfContext.hh>
#include <iostream>
#include <OpenCLFramework/Filter/clfGauss.hh>
#include <Filter/Mean.hh>
#include <Filter/Gauss.hh>
#include <OpenCLFramework/Filter/clfColorConversion.hh>
#include <OpenCLFramework/Filter/clfSimpleFilter.hh>
#include <Filter/StructureTensor.hh>
#include <FeatureDetector/CornerDetectorKLT.hh>
#include <Filter/GradientSimple.hh>
#include <Base/Debug/TimeMeasure.hh>


using namespace BIAS;
using namespace std;

/**
 * @brief mean filtering an image using opencl
 * 
 * test program for clfImage2D objects. The kernel mean3x3 filters an image
 * 
 */
int main(int argc, char* argv[]) {
  
  Param par;
  string *inname = par.AddParamString("image", "image", "", 'i');
  string *outname = par.AddParamString("out", "result", "climage.mip", 'o');
  bool *bench = par.AddParamBool("benchmark", "benchmark 100 (default) conversions on gpu againt cpu", false, 'b');
  int *numFrames = par.AddParamInt("numframes", "number of frames for benchmark", 100, 1, 10000, 'n');
  
  if (IOUtils::ParseCommandLineEvalHelp(par, argc, argv) == 0) {
    par.Usage();
  }
  
  Image<unsigned char> in;
  Image<unsigned char> out;
  ImageIO::Load(*inname, in);

  unsigned int w = in.GetWidth();
  unsigned int h = in.GetHeight();

  out.Init(w,h,4);

  try {

    // create context on first GPU found
    clfContext context(false);
    
    clfColorConversion convert(&context);
    
    clfImage2D *greyImage = context.CreateImage2D();
    clfImage2D *dstImage = context.CreateImage2D();
    greyImage->AllocateFromBiasImage(in, true, false, true);
    dstImage->AllocateFromBiasImage(out, false, true);
    
    if (in.GetColorModel() == ImageBase::CM_Bayer_RGGB) {
      cout << "doing bayer rggb to rgb" << endl;
      convert.UCharBayerToRGBA(greyImage, dstImage, ImageBase::CM_Bayer_RGGB);

      if (*bench) {
        // benchmark
        TimeMeasure tm;
        tm.Reset();
        tm.Start();
        for (int i=0;i<*numFrames;i++) {
          greyImage->WriteToImage( in.GetImageData() );
          convert.UCharBayerToRGBA(greyImage, dstImage, ImageBase::CM_Bayer_RGGB);
          dstImage->CopyToBiasImage(out);
        }
        tm.Stop();
        tm.Print(cout);
        double gputime = tm.GetRealTime();
        tm.Reset();
        Image<unsigned char> cpu;
        cpu.Init(w,h,3);
        tm.Start();
        for (int i=0;i<*numFrames;i++) {
          ImageConvert::ToRGB(in , cpu);
        }
        tm.Stop();
        tm.Print(cout);
        double cputime = tm.GetRealTime();

        cout << "GPU conversion runs at " << (1e6) / (gputime/(float)(*numFrames)) << " frames/sec." << endl;
        cout << "CPU conversion runs at " << (1e6) / (cputime/(float)(*numFrames)) << " frames/sec." << endl;
        cout << "GPU speed factor: " << cputime/gputime << "x"<<endl;
      }

    } else if (in.GetColorModel() == ImageBase::CM_YUYV422) {
      cout << "doing yuyv422 to rgb" << endl;
      convert.UCharYUYV422ToRGBA(greyImage, dstImage);

      if (*bench) {
        // benchmark
        TimeMeasure tm;
        tm.Reset();
        tm.Start();
        for (int i=0;i<*numFrames;i++) {
          greyImage->WriteToImage( in.GetImageData() );
          convert.UCharYUYV422ToRGBA(greyImage, dstImage);
          dstImage->CopyToBiasImage(out);
        }
        tm.Stop();
        tm.Print(cout);
        double gputime = tm.GetRealTime();
        tm.Reset();
        Image<unsigned char> cpu;
        cpu.Init(w,h,3);
        tm.Start();
        for (int i=0;i<*numFrames;i++) {
          ImageConvert::ToRGB(in , cpu);
        }
        tm.Stop();
        tm.Print(cout);
        double cputime = tm.GetRealTime();

        cout << "GPU conversion runs at " << (1e6) / (gputime/(float)(*numFrames)) << " frames/sec." << endl;
        cout << "CPU conversion runs at " << (1e6) / (cputime/(float)(*numFrames)) << " frames/sec." << endl;
        cout << "GPU speed factor: " << cputime/gputime << "x"<<endl;
      }
    }
    
    dstImage->CopyToBiasImage(out);
  } catch (clfException &err) {
    // the detailed error string
    cout << err.GetDetailedString() << endl;
  }
  // save result
  ImageIO::Save(*outname, out);
  
  return 0;
}