biasconvert.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 <Image/Camera.hh>
#include <Base/Image/ImageBase.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/Image/ImageConvert.hh>
#include <Base/Image/ImageAttributes.hh>
#include <Geometry/PMatrix.hh>
#include <bias_config.h>
#include <stdio.h>
#include <fstream>
#include <Utils/Param.hh>

#ifdef   WIN32
#  include "Base/Common/getopt_W32.h"
#else  //not WIN32
#  include <getopt.h>
#endif //WIN32

using namespace BIAS;
using namespace std;

/**
   @file
   @ingroup g_tools
   @brief Convert input image format to output image format, see biasconvert.cpp
   @author MIP
*/
void writePixelToFileFloat(void** imageArray, unsigned int w,
                           unsigned int h, ofstream& ofs) {
  float* row = (float*)imageArray[h];
  ofs<<row[w];
}

void writePixelToFileUChar(void** imageArray, unsigned int w,
                           unsigned int h, ofstream& ofs) {
   unsigned char* row = (unsigned char*)imageArray[h];
  ofs<<row[w];
}


int DetermineFiletype(const string &fn)
{
  return BIAS::ImageIO::GetFileFormat(fn);
}



void AdoptPMatrix(PMatrix &P,float scalex,float scaley)
{
  PMatrix *newP=NULL;
  Vector3<double> C;
  KMatrix K;
  Matrix3x3<double> R;

  if (P[0][0] != 0) {
    P.GetC(C);
    P.GetK(K);
    P.GetR(R);

    K[0][0] *= scalex;
    K[1][1] *= scaley;
    K[0][2] *= scalex;
    K[1][2] *= scaley;
    // the skew
    K[0][1] *= scaley;
    newP = new PMatrix(K,R,C);
    P = *newP;
  }
}



int ReadPMatrix(PMatrixBase &pmat,const string &filename)
{
  int row,col;
  ifstream pmatfile(filename.c_str());
  if (!pmatfile){
    cerr << "unable to open " << filename<< endl;
    perror("");
    return -1;
  }
  pmatfile >> row >> col;
  if (!pmatfile){
    cerr << "error reading " << filename << endl;
    return -1;
  }
  if (row!=3 || col!=4){
    cerr << "P Matrix should have size 3x4, not: " <<row<<"x"<<col << endl;
    return -1;
  }


  for (int r=0; r < row; r++)
    for (int c=0; c< col; c++)
      pmatfile >> pmat[r][c];
  return 0;

}

int ReadEXIF(const string &ifile, KMatrix &KExif, int &EXIFMode)
{
  //cout<<"reading exif tags"<<endl;
  ImageAttributes Att;
  Att.InitExifTags();
  if (Att.Read(ifile)!=BIAS_IMAGEATTRIBUTES_SUCCESS) {
    cerr<<"error reading exif tags ..."<<endl;
    EXIFMode = 0;
    return -1;
  } else {
    //Att.Print();
    KExif.SetIdentity();
    bool success = true;
    success = success && (Att.GetFocalLengthXPixel(KExif[0][0])>=0);
    success = success && (Att.GetFocalLengthYPixel(KExif[1][1])>=0);
    success = success && (Att.GetPrincipalPoint(KExif[0][2],
                                                KExif[1][2] )>=0);
    if (success) {
      cout<<"Found a K="<<KExif<<endl;
    } else {
      cout<<"Error, not enough EXIF data to get K:"<<KExif<<endl;
      EXIFMode = 0;
    }
    return (success)?(0):(-1);
  }
  return -7657;
}

int main (int argc, char *argv[])
{
  //    pic.SetDebugLevel(D_CAM_IO);
  Param param;
  bool *help = param.AddParamBool("help", "display help", false, 'h');
  bool *togrey = param.AddParamBool("toGrey", "convert image to grey image", false, 'g');
  bool *toHSL = param.AddParamBool("toHSL", "convert image to HSL image", false, 'l');
  bool *toRGB = param.AddParamBool("toRGB", "convert image to RGB image", false, 'r');

  bool *verbose = param.AddParamBool("verbose", "verbose output", false, 'v');
  int *EXIFMode = param.AddParamInt("KFromExif", "Compute K Matrix from exif data (0,1,2):", 0, 0, 2, 'e');
  string *pmatfile = param.AddParamString("PMatrixFile", "add P-Matrix", "", 'p');
  double *scale = param.AddParamDouble("modulate", "Modulate (scale) all pixel values", 1.0, -DBL_MAX, DBL_MAX, 'm'); 
  double *shift = param.AddParamDouble("offset", "Offset all pixels", 0.0, -DBL_MAX, DBL_MAX, 'o');
  double *newzero = param.AddParamDouble("newZero", "new value for zero (useful for inverting depth maps)", 0.0, -DBL_MAX, DBL_MAX, 'z');
  int *imagequality = param.AddParamInt("quality", "quality for lossy formats  [0;100] best=100", BIAS_DEFAULT_IMAGE_QUALITY, 0, 100, 'q');
  bool *clip = param.AddParamBool("clip", "clip values to [0,255], only effective if -m or -o", false, 'c');
  bool *convertToMatrix = param.AddParamBool("convertToMatrix", "convert to matrix textfile, readable my matlab with simple header", false, 'T');
  bool *convertFromMatrix = param.AddParamBool("convertFromMatrix", "convert from matrix textfile containing rows cols colorchannels and interleaved flag in the first line and then the image matrix row by row", false, 'F');
  bool *ToIMA = param.AddParamBool("convertToIma", "convert into binary ima fileformat needed by RealEyes", false, 'I');

  vector<string> st_enum;
  vector<int> st_ids;
  st_enum.push_back("auto"); st_ids.push_back(ImageBase::ST_invalid);
  st_enum.push_back("unsignedchar"); st_ids.push_back(ImageBase::ST_unsignedchar);
  st_enum.push_back("float"); st_ids.push_back(ImageBase::ST_float);
#ifdef BUILD_IMAGE_USHORT
  st_enum.push_back("unsignedshort"); st_ids.push_back(ImageBase::ST_unsignedshortint);
#endif
  int *outstparam = param.AddParamEnum("storageType", "Output Storage Type", st_enum, ImageBase::ST_invalid, &st_ids, 's');
  bool replacezero = false;
  bool maxDynamics = false;

  int fup = param.ParseCommandLine(argc, argv);

  bool scaleshift = (*scale != 1.0 || *shift != 0.0);

  if (*help || argc <3) {
    cout << "Usage: " << argv[0] << " [options] infile outfile\n";
    param.Usage();
    cout <<"if neither -m nor -o is given float images are scaled \n"
    <<"and shifted automatically"<<endl;
    return 0;
  }
  string ifile = argv[fup];
  string ofile = argv[fup+1];

  ImageBase ipic;
  
  Camera<unsigned char> ucocam;
  Camera<float> focam;
#ifdef BUILD_IMAGE_USHORT
  Camera<unsigned short> usocam;
#endif
  ImageBase::EStorageType OutST = ImageBase::ST_invalid;
  ImageIO::TFileFormat ofiletype = ImageIO::FF_unknown;

  Camera<unsigned char> opic;
  PMatrix P_;

  // after getopt() all recognized options are before non-options
  ifile = argv[argc-2];
  ofile = argv[argc-1];

  if (*newzero != 0.0) {
    replacezero = true;
  }
  ///////////////////////////////////////
  //check for matlab ot image file format
  if(!*convertToMatrix && !*ToIMA) {
    //determine output image format
    // if no ending is given it is saved as auto (mip)
    ofiletype = (ImageIO::TFileFormat)DetermineFiletype(ofile);
    if ((ofiletype ==-1) || (ofiletype==ImageIO::FF_unknown)){
      BIASWARN("unknown FileFormat"<<ofile);
      ofiletype =ImageIO::FF_auto;
    }

    if (ofiletype == ImageIO::FF_pgm)
      *togrey = true;
  }
  
  if (*verbose) {
    cout <<"load "<<ifile<<", "<<flush;
  }
  ///////////////////////////////////////////////////////
  //check for text file images, like Matlab 
  if (*convertFromMatrix) {
    if (ImageIO::ImportMatrix(ifile,ipic,*verbose)!=0) return -1;
  } else {
    if (ImageIO::Load(ifile,ipic)<0){
      BIASERR("could not load " <<ifile);
      exit(1);
    }
  }

  if (*outstparam != ImageBase::ST_invalid && !scaleshift) {
    if (ipic.GetStorageType() != *outstparam) {
      ImageBase convtemp;
      ImageConvert::ConvertST(ipic, convtemp, (ImageBase::EStorageType)(*outstparam));
      ipic.StealImage(convtemp);
    }
  }
  
  ///////////////////////////////////////////////////////
  //if output file format is auto, call Save() and return
  if(ofiletype ==ImageIO::FF_auto){
    return BIAS::ImageIO::Save(ofile,ipic);
  }

  //check if it is IMA file format, call Write and return
  if(*ToIMA) {
    cout<<"writing IMA format (RealEyes)\n";
    Image<unsigned char> flipped(ipic);
    flipped.Flip();
    ImageBase sink(ipic.GetWidth(), ipic.GetHeight(),
                   ipic.GetChannelCount(), ImageBase::ST_unsignedchar,
                   false);

    ImageConvert::Convert(flipped, sink, ImageBase::CM_RGB, true);
    return ImageIO::WriteRAW_IMA(ofile, sink);
  }

  if (*verbose) ipic.PrintHeader();
  
  ///////////////////////////////////////
  //check for matlab call WriteMatlab and return
  if(*convertToMatrix) {
    string filename =ImageIO::ExtensionName( ofile, ImageIO::GetExtension(ImageIO::FF_matrix) );
    if(filename != ofile) {
      BIASWARNONCE("Changed filenames to extension .matrix")
    }
    return ImageIO::ExportMatrix(filename,ipic,*verbose);
  }

  KMatrix KExif;
  if (*EXIFMode>0) {
    if (ReadEXIF(ifile, KExif, *EXIFMode)!=0) return -1;
  }

  if (ipic.GetStorageType() == ImageBase::ST_float) {
    if (verbose) cout <<"storagetype is float"<<endl;
    Camera<float> fcam(ipic);
    fcam.ParseMetaData();
    P_ = fcam.GetP();

    //check for other types than MIP or OpenEXR
    //means we convert to UCHAR
    if (ofiletype != ImageIO::FF_mip && ofiletype != ImageIO::FF_exr) {
      if (scaleshift){
        if (*verbose) {
          float min,max;
          fcam.GetMinMaxPixelValue(min,max);
          cout << "min = " << min << ", max = " << max << endl;
        }

        float mean =0.0;
        float *fcamptr=fcam.GetImageData();
        float num_elem=0;
        //float max=(255-shift)/scale;
        //float min=-shift/scale;
        for (unsigned int i = 0; i < fcam.GetWidth()*fcam.GetHeight(); i++){
          if (*fcamptr != -1.0){
            mean += *fcamptr;
            num_elem++;
          }
          fcamptr++;
        }

        mean /= num_elem;
        fcamptr=fcam.GetImageData();
        float variance=0.0;
        float scaledmean=0.0;
        for (unsigned int i = 0; i < fcam.GetWidth()*fcam.GetHeight();i++){
          if (*fcamptr != -1.0)
            variance += (*fcamptr-mean)*(*fcamptr-mean);
        }

        fcam.ScaleShift(*scale,*shift);
        fcamptr=fcam.GetImageData();
        if (clip)
          for (unsigned int i = 0; i < fcam.GetWidth()*fcam.GetHeight();i++){
            *fcamptr = (*fcamptr < 255) ? *fcamptr : 255 ;
            *fcamptr = (*fcamptr > 0) ? *fcamptr : 0 ;
            scaledmean += *fcamptr;
            fcamptr++;
          }

        if (*verbose){
          variance/= num_elem;
          cout << "mean = " << mean  << ", scaledmean="
               << scaledmean/num_elem
               << ", variance = "
               << variance <<  ", fill rate = "
               <<  num_elem/fcam.GetWidth()/fcam.GetHeight() << endl;
        }
      } else {
        if (*verbose) {
          float min,max;
          fcam.GetMinMaxPixelValue(min,max);
          cout << "min = " << min << ", max = " << max << endl;
        }
        fcam.ScaleShiftBetween(0,255);
      }
      //ucocam = fcam;
      //OutST = ImageBase::ST_float;
      OutST = ImageBase::ST_unsignedchar;
      ImageConvert::ConvertST(fcam, ucocam, OutST );
      // copy meta data to ucocam
      *ucocam.GetMetaData()=*fcam.GetMetaData();
      ucocam.ParseMetaData();
    }//end if (ofiletype != ImageIO::FF_mip && ofiletype != ImageIO::FF_exr) 
    
    else {//this is ofiletype==mip || type ==exr

        if (*togrey) ImageConvert::ToGrey(fcam , focam);
        else if(*toHSL) ImageConvert::ToHSL(fcam, focam);
        else if(*toRGB) ImageConvert::ToRGB(fcam, focam);
        else    focam = fcam;

        if (replacezero) { 
            /*if (newzero==0.0) {
                   float min, max;
                   // automatic value range detection
                   focam.GetMinMaxPixelValue(min,max);
                   newzero = min - (max-min / 20.0);
                  } */
            float *focamptr = focam.GetImageData(),
            *fcamptr = fcam.GetImageData();
            for (unsigned int i = 0; i < focam.GetWidth()*focam.GetHeight();i++){
                if ((*fcamptr) <= 0) {
                    *focamptr = float(*newzero);
                    //cout<<"0";
                }
                fcamptr++;
                focamptr++;
            }
        } //end replace zero

        if (scaleshift) {
            focam.ScaleShift(*scale,*shift);
        }//end scaleshift
        OutST = ImageBase::ST_float;
    }

  }// end if (ipic.GetStorageType() == ImageBase::ST_float) {  
  /////////unsigned char input images //////////////
  else if (ipic.GetStorageType() == ImageBase::ST_unsignedchar)  {
#ifdef BIAS_DEBUG
    if (verbose) {
      if (Debug::GetGlobalDebugLevel()<D_CONVERT)
        Debug::SetGlobalDebugLevel(D_CONVERT);
    }
#endif
    if (*verbose) cout <<"storagetype is unsigned char"<<endl;
    Camera<unsigned char> uccam(ipic);
    OutST = ImageBase::ST_unsignedchar;
    uccam.ParseMetaData();
    P_ = uccam.GetP();

    // all meta datas are preserved now (felix)
    if (*verbose) cout <<"P: "<<P_<<endl;

    if (scaleshift) {
      if (*scale>1.0) {
        BIASWARN("You scale an unsigned char image with more than 1.0");
      }
      uccam.ScaleShift(*scale,*shift);
    }
    // meta datas are lost here
    if (*togrey) ImageConvert::ToGrey(uccam, ucocam);
    else if(*toHSL) ImageConvert::ToHSL(uccam, ucocam);
    else if(*toRGB) ImageConvert::ToRGB(uccam, ucocam);
    else ImageConvert::ToRGB(uccam, ucocam);

    // copy meta data to ucocam
    *ucocam.GetMetaData()=*uccam.GetMetaData();
    ucocam.ParseMetaData();
  }// end if (ipic.GetStorageType() == ImageBase::ST_unsignedchar)
  ////////////unsigned short input images //////////////
#ifdef BUILD_IMAGE_USHORT
  else if (ipic.GetStorageType() == ImageBase::ST_unsignedshortint)  {
#  ifdef BIAS_DEBUG
    if (*verbose) {
      if (Debug::GetGlobalDebugLevel()<D_CONVERT)
        Debug::SetGlobalDebugLevel(D_CONVERT);
    }
#  endif
    if (*verbose)
      cout << "input storagetype is unsigned short int"<<endl
           << "output file type is "<<ofiletype<<endl;
    Camera<unsigned short> uscam(ipic);
    if (ofiletype!=ImageIO::FF_mip){
      Camera<unsigned char> tmpcam;
      OutST = ImageBase::ST_unsignedchar;
      uscam.ParseMetaData();
      P_ = uscam.GetP();
      // uccam.GetTime(sec,usec);
      // all meta datas are preserved now (felix)
      if (verbose) cout <<"P: "<<P_<<endl;

      // now scale and shift if necessary
      if (scaleshift){
        Image<float> foim;
        ImageConvert::ConvertST(uscam, foim, ImageBase::ST_float);
        foim.ScaleShift(*scale, *shift);
        if (clip){
          foim.BelowThresholdToValue(0.0, 0.0);
          foim.AboveThresholdToValue(255.0, 255.0);
        }
        ImageConvert::ConvertST(foim, tmpcam, OutST);
      } else {
        ImageConvert::ConvertST(uscam, tmpcam, OutST);
      }

      // meta datas are lost here
      if (*togrey) ImageConvert::ToGrey(tmpcam, ucocam);
      else if(*toHSL) ImageConvert::ToHSL(tmpcam, ucocam);
      else if(*toRGB) ImageConvert::ToRGB(tmpcam, ucocam);
      else if (ipic.GetChannelCount()!=1) ImageConvert::ToRGB(tmpcam, ucocam);

      // copy meta data to ucocam
      *ucocam.GetMetaData()=*uscam.GetMetaData();
      ucocam.ParseMetaData();
    } else { // do not convert, output can be written as
      OutST = ImageBase::ST_unsignedshortint;

      // meta datas are lost here
      if (*togrey) ImageConvert::ToGrey(uscam, usocam);
      else if(*toHSL) ImageConvert::ToHSL(uscam, usocam);
      else if(*toRGB) ImageConvert::ToRGB(uscam, usocam);
      else if (ipic.GetChannelCount()!=1) ImageConvert::ToRGB(uscam, usocam);
      else usocam = uscam;

      // copy meta data to ucocam
      *usocam.GetMetaData()=*uscam.GetMetaData();
      usocam.ParseMetaData();
    }
    if (*verbose) cout << "output storage type is "<<OutST<<endl;
  } //end if (ipic.GetStorageType() == ImageBase::ST_unsignedshortint)  {
#endif

  if (*pmatfile != "") {
    if (*verbose) cout <<"read "<<*pmatfile<<", ";
    if (ReadPMatrix(P_,*pmatfile) < 0)
      exit(1);
    ucocam.SetP(P_);
    focam.SetP(P_);
  }

  //   if (downbypoweroftwo >0) {
  //     if (verbose) cout <<"rescale, "<<flush;
  //     Filter f;
  //     Camera<unsigned char> tmppic;
  //     f.DownsampleByPowerOfTwo(opic,tmppic,downbypoweroftwo);
  //     opic = tmppic;
  //     AdoptPMatrix(P_, scalex,scaley);
  //   }
  
  ///////////////////////////////////////////
  // now switch over output storage type
  ///////////////////////////////////////////
  if (OutST == ImageBase::ST_unsignedchar) {
    if (EXIFMode>0) ucocam.SetK(KExif);
    ucocam.UpdateMetaData();
    if (*verbose) cout <<"write unsigned char "<<ofile<<", "<<flush;
    if (ofiletype == ImageIO::FF_mip) {
      if(maxDynamics)
        ucocam.ScaleShiftBetween(0,255);
      //ImageIO::Save(ofile, ucocam);
      ImageIO::Save(ofile, ucocam);
    } else {
      //     if (ofiletype !=ImageIO::FF_ppm && ofiletype !=ImageIO::FF_pgm) {
      if (ucocam.GetChannelCount() == 1 && (ofiletype == ImageIO::FF_png || ofiletype == ImageIO::FF_jpg)) {
        Camera<unsigned char> tmp = ucocam;
        ImageConvert::ToRGB(tmp, ucocam);
      }
      string::size_type endofprefix = ofile.rfind('.');
      ofile = ofile.substr(0,endofprefix);
      ImageIO::Save(ofile,ucocam,ofiletype,false,*imagequality);
    }
  } else if (OutST == ImageBase::ST_float) {
    // all meta datas are preserved now (felix)
    if (*EXIFMode>0) focam.SetK(KExif);
    focam.UpdateMetaData();
    if(maxDynamics)
      focam.ScaleShiftBetween(0,255);
    ImageIO::Save(ofile, focam);
   // ImageIO::Save(ofile, focam);
    if (*verbose) cout <<"write float "<<ofile<<", "<<flush;
  }
#ifdef BUILD_IMAGE_USHORT
  else if (OutST == ImageBase::ST_unsignedshortint) {
    if (*EXIFMode>0) usocam.SetK(KExif);
    usocam.UpdateMetaData();
    //ImageIO::Save(ofile, usocam);
    ImageIO::Save(ofile, usocam);
    if (*verbose) cout <<"write unsigned short "<<ofile<<", "<<flush;
  }
#endif

  if (*verbose) cout <<"done"<<endl;

  return 0;
}