biasfilter.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
*/

#include <Base/Image/Image.hh>
#include <Filter/Mean.hh>
#include <Filter/Gauss.hh>
#include <Filter/Median.hh>
#include <Filter/Rescale.hh>
#include <Base/Image/ImageIO.hh>
#include <Utils/Param.hh>
#include <Utils/IOUtils.hh>

#ifndef  WIN32
#include <unistd.h>
#endif //WIN32

using namespace std;
using namespace BIAS;


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

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


void usage()
{
  cout <<"Usage: biasfilter [options] infile outfile"<<endl
       <<" Options: "<<endl
       <<"-r radius  : size of the filter kernel: size = 2 * radius + 1"<<endl
       <<"-a         : use mean filter"<<endl
       <<"-g         : use gauss filter"<<endl
       <<"-b         : use median filter"<<endl
       <<"-s         : scale image, give factor with ="<<endl

       <<"-v         : verbose"<<endl
       <<"-t thresh  : median: ignore x<=thresh"<<endl;
}

int main(int argc, char *argv[])
{
  Median<unsigned char , unsigned char> MedianFilterUC;
  Median<float, float> MedianFilterFLT;
  Mean<unsigned char, unsigned char> meanfilterUC;
  Mean<float, float> meanfilterFLT;
  Gauss<unsigned char, unsigned char> gaussfilterUC;
  Gauss<float, float> gaussfilterFLT;
  Rescale<unsigned char, unsigned char> rescalefilterUC;
  Rescale<float, float> rescalefilterFLT;

  MedianFilterUC.SetBorderHandling(FilterBase<unsigned char , unsigned char>::TBH_same);
  MedianFilterFLT.SetBorderHandling(FilterBase<float, float>::TBH_same);
  meanfilterUC.SetBorderHandling(FilterBase<float, float>::TBH_same);
  meanfilterFLT.SetBorderHandling(FilterBase<float, float>::TBH_same);
  gaussfilterUC.SetBorderHandling(FilterBase<unsigned char , unsigned char>::TBH_same);
  gaussfilterFLT.SetBorderHandling(FilterBase<float, float>::TBH_same);
  rescalefilterUC.SetBorderHandling(FilterBase<unsigned char , unsigned char>::TBH_same);
  rescalefilterFLT.SetBorderHandling(FilterBase<float, float>::TBH_same);
  //  RankValue rankvaluefilter;

  Param param;
  vector<string> enums;
  vector<int> ids;
  enums.push_back("None");   ids.push_back(none);
  enums.push_back("Mean");   ids.push_back(mean);
  enums.push_back("Median"); ids.push_back(median);
  enums.push_back("Gauss");  ids.push_back(gauss);
  enums.push_back("Rescale");ids.push_back(rescale);
  int *filter = param.AddParamEnum("FilterType","The filter to apply",enums,0,&ids,'f');
  int *rad = param.AddParamInt("Radius", "Radius of image filter", 3,1,1000,'r');
  int *threshold = param.AddParamInt("Threshold", "threshold for image filter", 0,1,100000000,'t');
  int *factor = param.AddParamInt("Factor", "Rescale factor", 0,1,100000000,'s');
  bool *verbose = param.AddParamBool("Verbose", "Verbose output", false,'v');
  string *input = param.AddParamString("Input", "Input image to filter", "", 'i');
  string *output = param.AddParamString("Output", "Output image for result", "out.mip", 'o');

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

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

  MedianFilterUC.SetSize(*rad);
  MedianFilterFLT.SetSize(*rad);
  meanfilterUC.SetSize(*rad);
  meanfilterFLT.SetSize(*rad);
  gaussfilterUC.SetHalfWinSize(*rad);
  gaussfilterFLT.SetHalfWinSize(*rad);
  rescalefilterUC.SetFactor(*factor);
  rescalefilterFLT.SetFactor(*factor);


  if (*verbose){
    switch (UseFilter) {
    case median: cout<<"Median filter "<<endl;//on zero values";
      break;
    case mean: cout<<"Mean filter"<<endl;
      break;
    case gauss: cout<<"Gauss filter"<<endl;
      break;
    case rescale: cout<<"Rescale filter with factor: "<<rescale<<endl;
      break;
    default: ;
    }
    cout <<" size "<<2*(*rad)+1<<"x"<<2*(*rad)+1<<endl;
    if (*threshold > -FLT_MAX) cout <<" threshold "<<*threshold<<endl;
  }

  ImageBase inimage,outimage;
  if (ImageIO::Load(*input,inimage)<0){
    BIASERR("Could not load input image:"<<*input);
    exit(1);
  }

  if (inimage.GetStorageType() == ImageBase::ST_unsignedchar) {
    Image<unsigned char> img1(inimage),img2;
    switch (UseFilter){
    case median:
      if(inimage.GetChannelCount() == 1)
        MedianFilterUC.Filter(img1, img2);
      else
        MedianFilterUC.FilterColorImg(img1, img2);
      break;
    case mean:
        // \bug mean filter  moves image content to left top corner by at least one pixel!
      meanfilterUC.Filter(img1,img2);
      break;
    case gauss:
      gaussfilterUC.Filter(img1,img2);
      break;
    case rescale:
      rescalefilterUC.Filter(img1,img2);
      break;
    default:
      cout <<"==> No filtertype specified."<<endl;
      usage();
      exit(1);
      break;
    }
    ImageIO::Save(*output,img2);
  }
  else if (inimage.GetStorageType() == ImageBase::ST_float) {
    Image<float> img1(inimage),img2;
    switch (UseFilter){
    case median:
      //MedianFilterFLT.FilterOnlyZeroIgnoreZero3x3(img1, img2);
      MedianFilterFLT.Filter(img1, img2);
      break;
    case mean:
      meanfilterFLT.Filter(img1,img2);
      break;
    case gauss:
      gaussfilterFLT.Filter(img1,img2);
      break;
    case rescale:
      rescalefilterFLT.Filter(img1,img2);
      break;
    default:
      cout <<"==> No filtertype specified."<<endl;
      usage();
      exit(1);
      break;
    }
    ImageIO::Save(*output,img2);
  }
  else{
    BIASERR("Neither a unsigned char nor a float image, returning unfiltered.");
  }
  return 0;
}