biasGPUFilter.cpp

#include <Base/Image/Image.hh>
#include <Base/Image/ImageIO.hh>
#include <OpenGLFramework/SpecializedBatches/GpuImageFilter.hh>
#include <OpenGLFramework/Base/glfException.hh>
#include <OpenGLFramework/RenderingContext/glfPBuffer.hh>

#ifndef  WIN32
#include <unistd.h>
#else  //WIN32
#include "Base/Common/getopt_W32.h"
#endif //WIN32
using namespace std;
using namespace BIAS;

/**@file
     @ingroup g_tools
     @brief Tool to filter an image with Mean, Gauss or Median, see biasGPUFilter.cpp
     @author djung */

/** \internal */
enum filtertype {
  none, mean, median, gauss
};

void usage() {
  cout << "Usage: biasGPUfilter [options] infile outfile" << endl;
  cout << " Options: " << endl;
  cout << "-r radius  : size of the filter kernel: size = 2 * radius + 1" << endl;
  cout << "-a         : use mean filter" << endl;
  cout << "-g         : use gauss filter" << endl;
  cout << "-b         : use median filter" << endl;
  cout << "-v         : verbose" << endl;
  cout << "-p         : median: independent channel sort. Else sort will be done on grey values" << endl;
  cout << "-t thresh  : gauss: sigma-value" << endl;
}

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

  filtertype UseFilter = none;
  int rad = -1;
  int c = 1;
  float threshold = -FLT_MAX;
  bool verbose = false;
  bool planar = false;

  while (c > 0) {
    c = getopt(argc, argv, "r:abpt:vg:");
    if (c > 0) {
      switch (c) {
        case 'a':
          UseFilter = mean;
        break;
        case 'b':
          UseFilter = median;
        break;
        case 'g':
          UseFilter = gauss;
        break;
        case 'r':
          rad = atoi(optarg);
        break;
        case 't':
          threshold = float(atof(optarg));
        break;
        case 'v':
          verbose = true;
        break;
        case 'p':
          planar = true;
        break;
        default:
          usage();
          exit(1);
      }
    }
  }

  if (argc - optind < 2) {
    cout << "==> To few arguments." << endl;
    usage();
    exit(1);
  }

  if (UseFilter == none) {
    cout << "==> No filtertype specified." << endl;
    usage();
    exit(1);
  }

  if (verbose) {
    switch (UseFilter) {
      case median:
        cout << "Median filter ";
        if (planar) {
          cout << " planar ";
        }
        else {
          cout << " grey ";
        }
      break;
      case mean:
        cout << "Mean filter";
      break;
      case gauss:
        cout << "Gauss filter";
      break;
      default:
      break;
    }
    cout << " size " << 2 * rad + 1 << "x" << 2 * rad + 1;
    if (threshold > -FLT_MAX) cout << " threshold " << threshold;
    cout << " : " << argv[optind] << " -> " << argv[optind + 1] << endl;
  }

  ImageBase inImage, outImage;
  if (ImageIO::Load(argv[optind], inImage) < 0) exit(1);

  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);

    GpuImageFilter gpuFilter;

    switch (UseFilter) {
      case median:
        if (rad > 15) {
          BIASERR("Median is limited a half-window size of 15"<<endl);
          return -1;
        }
        if (rad > 5) {
          BIASWARN("Median with rad > 5 will most likely not work on the GPU with this implementation"<<endl<<" -> check the image for artefacts!");
        }
        gpuFilter.FilterMedian(inImage, outImage, inImage.GetStorageType(), rad, threshold, planar);
      break;
      case mean:
        gpuFilter.FilterMean(inImage, outImage, inImage.GetStorageType(), rad, threshold);
      break;
      case gauss:
        if (threshold < 0.) {
          threshold = 1.;
        }
        gpuFilter.FilterGauss(inImage, outImage, inImage.GetStorageType(), rad, threshold);
      break;
      default:
        cout << "==> No filtertype specified." << endl;
        usage();
        exit(1);
      break;
    }
  }
  catch (glfException& e) {
    pbuffer.Destroy();
    std::cout << "Error: " << e.GetMessageString() << std::endl;
    return -1;
  }

  ImageIO::Save(argv[optind + 1], outImage);

  return 0;

}