biasdiff.cpp

// must be first:
//#include <Base/Common/LeakChecking.h>

#include <Base/Image/ImageIO.hh>
#include "Base/Image/ImageConvert.hh"
#include "Utils/Param.hh"
#include <stdio.h>
#include <iostream>

using namespace BIAS;
using namespace std;



/** @file
    @ingroup g_tools
    @brief tool for computing intensity difference of images, see biasdiff.cpp
    @author woelk */

int main(int argc, char *argv[]){
  // Dart Testing (JW)
  if (argc>=2) if (strcmp(argv[1],"-darttest")==0){
    std::cout<<"started dart test: "<<argv[0]<<std::endl;
    return 0;
  }


  Param param;
  param.AddParamInt("border", "sets ROI", 0, 0,INT_MAX,'b');
  param.AddParamBool("absdiff","if set calculates abs difference else im1-im2",false, 'a');
  param.AddParamBool("help","",false, 'h');
  param.AddParamBool("grey", "converts images to grey", false,'g');
  param.AddParamBool("zeroexclude", "do not use zero values", false,'z');
  param.AddParamBool("exclude_negative", "do not use negative values", false,'n');
  int next = param.ParseCommandLine(argc, argv);

  param.DisableDestructorWarning();

  if (argc<3 || *param.GetParamBool("help")){
    param.Usage();
    return -1;
  }

  ImageBase im1, im2, diff;
  if (ImageIO::Load(argv[next], im1)!=0){
    BIASERR("error loading "<<argv[next]);
    return -1;
  }
  if (ImageIO::Load(argv[next+1], im2)!=0){
    BIASERR("error loading "<<argv[next+1]);
    return -1;
  }

  if (!im1.SamePixelAndChannelCount(im2) ||
      im1.GetWidth() != im2.GetWidth() ||
      im1.GetHeight() != im2.GetHeight()){
    BIASERR("image sizes do not match");
    return -2;
  }

  if (*param.GetParamBool("grey")){
    ImageBase tmp;
    ImageConvert::ToGrey(im1, tmp);
    im1 = tmp;
    ImageConvert::ToGrey(im2, tmp);
    im2 = tmp;
  }

  int border = *param.GetParamInt("border");
  bool zeroExclude = *param.GetParamBool("zeroexclude");
  bool excludeNegative = *param.GetParamBool("exclude_negative");

  string newfilename;
  string fn1,fn2;
  fn1 = argv[next];
  fn2 = argv[next+1];
  fn1 = FileHandling::Basename(fn1); //fn1.substr(0,fn1.rfind('.'));
  fn2 = FileHandling::Basename(fn2); //fn2.substr(0,fn2.rfind('.'));
  newfilename = fn1+'_'+fn2+"_diff";

  im1.SetROI(border, border, im1.GetWidth()-border, im1.GetHeight()-border);
  im2.SetROI(border, border, im2.GetWidth()-border, im2.GetHeight()-border);
  BIASASSERT(im1.GetWidth()==im2.GetWidth());
  BIASASSERT(im1.GetHeight()==im2.GetHeight());

  Image<float> fim1, fim2, fdiff;
  Image<unsigned char> ucim1, ucim2, ucdiff;
  float fmin, fmax;
  unsigned char ucmin, ucmax;

  switch (im1.GetStorageType()){
  case ImageBase::ST_unsignedchar:
    ucim1=im1;
    ucim2=im2;

    if (zeroExclude) {
      unsigned char **p1 = ucim1.GetImageDataArray();
      unsigned char **p2 = ucim2.GetImageDataArray();
      const unsigned int channels = ucim1.GetChannelCount();
      // make consistent zeros, for inspection of rendered depth maps
      for (unsigned int y=0; y< ucim1.GetHeight(); y++) {
        for (unsigned int x=0; x< ucim1.GetWidth(); x++) {
          for (unsigned int c=0; c< ucim1.GetChannelCount(); c++) {
            if (p2[y][channels*x+c]==0 || p1[y][channels*x+c]==0)
              p2[y][channels*x+c] = p1[y][channels*x+c] = 0;
          }
        }
      }
    }
    if(*param.GetParamBool("absdiff")){
      ucdiff.AbsDiff(ucim1, ucim2);
    } else {
      ImageConvert::ConvertST(ucim1,fim1, ImageBase::ST_float);
      ImageConvert::ConvertST(ucim2,fim2, ImageBase::ST_float);
      fim1 -= fim2;
      fim1.ScaleShiftBetween(0.0,255.0);
      ImageConvert::ConvertST(fim1,ucdiff, ImageBase::ST_unsignedchar);
    }

    //if (ImageIO::Save(newfilename, ucdiff)!=0){
    if (ImageIO::Save(newfilename, ucdiff)!=0){
      cerr << "error writing diff.mip "<<endl;
    }
    ucdiff.GetMinMaxPixelValue(ucmin, ucmax);
    cerr << "differences between "<<(int)ucmin<<" and "<<(int)ucmax<<endl;
    if (ucdiff.ScaleShiftBetween(0, 255)!=0){
      BIASERR("error scaling image");
    }
    //if (ImageIO::Save(newfilename+"-scaled", ucdiff)!=0){
    if (ImageIO::Save(newfilename+"-scaled", ucdiff)!=0){
      cerr << "error writing diff-scaled.mip "<<endl;
    }
    break;
  case ImageBase::ST_float:
    fim1=im1;
    fim2=im2;

    if (zeroExclude || excludeNegative) {
      float **p1 = fim1.GetImageDataArray();
      float **p2 = fim2.GetImageDataArray();
      // make consistent zeros, for inspection of rendered depth maps
      for (unsigned int y=0; y< fim1.GetHeight(); y++) {
        for (unsigned int x=0; x< fim1.GetWidth(); x++) {
          if (excludeNegative){
            if (p2[y][x]<=0.0 || p1[y][x]<=0.0){
              p2[y][x] = p1[y][x] = 0;
            }
          } else {
            if (p2[y][x]==0 || p1[y][x]==0){
              p2[y][x] = p1[y][x] = 0;
            }
          }
        }
      }
    }
    if(*param.GetParamBool("absdiff"))
      fdiff.AbsDiff(fim1, fim2);
    else
      {
        fdiff = fim1 - fim2;
      }

    //if (ImageIO::Save(newfilename, fdiff)!=0){
    if (ImageIO::Save(newfilename, fdiff)!=0){
      cerr << "error writing diff.mip "<<endl;
    }
    fdiff.GetMinMaxPixelValue(fmin, fmax);
    cerr << "differences between "<<fmin<<" and "<<fmax<<endl;
    break;
  default:
    cerr << "unknown storage type\n";
    break;
  }

  return 0;
}