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

/**
   @file
   @ingroup g_tools
   @brief converts various Bayer pattern images to RGB images, see biasapplybayer.cpp
   @author bartczak
 */

#include <Base/Image/Image.hh>
#include <Base/Image/ImageConvert.hh>
#include <Base/Image/ImageIO.hh>
#include <Image/Camera.hh>
#include <Utils/IOUtils.hh>
#include <Utils/Param.hh>
#if !defined(WIN32) && defined(BIAS_HAVE_DC1394)
#include <Image/ConvertBayerPattern.hh>
#endif

using namespace std;
using namespace BIAS;

bool ApplyHalfingBayerConversion(Image<unsigned char>& in,
                                 Camera<unsigned char>& out);

void PrintHelp() {
  cout << "use: biasapplybayer [options] in out pattern [projection]" << endl;
  cout << "in: input image (mip)" << endl;
  cout << "out: output image (mip)" << endl;
  cout << "pattern: RGGB, GBRG, ..." << endl;
  cout << "projection: camera projection params to be set (optional)" << endl;
 
}


int main(int argc, char* argv[]) {
#if !defined(WIN32) && defined(BIAS_HAVE_DC1394)
    ConvertBayerPattern<unsigned char> demosaic;
#endif

  Param params(true);
  bool* half = 
    params.AddParamBool("half", 
                        "Discards half of the green pixels. "
                        "No interpolation resulting image has half resolution.",
                        false, 'H');
  int fup = 0; //first unknown argument index
  if(!IOUtils::ParseCommandLineEvalHelp(params, argc, argv, fup) || fup + 2 >= argc) {
    PrintHelp();
    return 0;
  }

  Projection proj;
  bool bsetproj_ = false;

  if (argc-fup==4) {
    if (proj.Load(argv[fup+3]) != 0) {
      BIASERR("error loading projection!");
      return -1;
    } else {
      bsetproj_ = true;
    }
  }

  Image<unsigned char> in;
  Camera<unsigned char> out;

  const int 
    inIndex = fup,
    outIndex = fup+1,
    patternIndex = fup+2;
  

  BIAS::ImageBase::EColorModel pattern = 
      BIAS::ImageBase::CM_invalid;
  if (strcmp(argv[patternIndex], "BGGR")==0) {
    cout << "converting bayer BGGR to RGB (" << argv[inIndex] << " => " << argv[outIndex] << ")" << endl;
    pattern = ImageBase::CM_Bayer_BGGR;
  } else if (strcmp(argv[patternIndex], "GBRG")==0) {
    cout << "converting bayer GBRG to RGB (" << argv[inIndex] << " => " << argv[outIndex] << ")" << endl;
    pattern = ImageBase::CM_Bayer_GBRG;
  } else if (strcmp(argv[patternIndex], "GRBG")==0) {
    cout << "converting bayer GRBG to RGB (" << argv[inIndex] << " => " << argv[outIndex] << ")" << endl;
    pattern = ImageBase::CM_Bayer_GRBG;
  } else if (strcmp(argv[patternIndex], "RGGB")==0) {
    cout << "converting bayer RGGB to RGB (" << argv[inIndex] << " => " << argv[outIndex] << ")" << endl;
    pattern = ImageBase::CM_Bayer_RGGB;
  } else {
    cout << argv[patternIndex]<<"? i dont know this pattern... abort!" << endl;
  }
  ImageIO::Load(argv[inIndex], in);

  in.SetColorModel(pattern);

  if(!*half) {  
#if !defined(WIN32) && defined(BIAS_HAVE_DC1394)
    out.Release();
    out.Init(in.GetWidth(), in.GetHeight(), 3);
    if (in.GetChannelCount() == 1){
        demosaic.Convert(in, out);
        cout<<"Schoen!"<<endl;
    }
    else
        ImageConvert::ToRGB(in, out);
    out.SetMetaData(*in.GetMetaData());     
#else
    ImageConvert::ToRGB(in, out);
#endif

  } else {
    if(!ApplyHalfingBayerConversion(in, out)) {
      return -1;
    }
    proj.Rescale(2.0);
  }

  if (bsetproj_) {
    if (out.SetProj(proj)!=0) {
      cout << "warning: cannot set projection parameters" << endl;
    }
    out.UpdateMetaData();
  }
  //  IOUtils::SaveCamera(argv[outIndex], out);

  ImageIO::Save(argv[outIndex], out);

  return 0;
}


bool ApplyHalfingBayerConversion(Image<unsigned char>& in,
                                 Camera<unsigned char>& out)
{

  unsigned int width = in.GetWidth();
  unsigned int height = in.GetHeight();
  
  bool even = (width%2 == 0) && (height%2 == 0);
  if(!even) {
    BIASERR("cannot half this resolution!");
    return false;
  }
  unsigned int sinkWidth = width/2;
  unsigned int sinkHeight = height/2;
  out.Release();
  out.Init(sinkWidth, sinkHeight, 3);

  int offsetR, offsetB;
  int index = 0, indexG = 0;
  BIAS::ImageBase::EColorModel pattern = in.GetColorModel();
  switch(pattern) {
  case ImageBase::CM_Bayer_BGGR :
    indexG = 1;
    offsetR = width;
    offsetB = -1;
    break;
  case ImageBase::CM_Bayer_RGGB :
    indexG = 1;
    offsetR = -1;
    offsetB = width;
    break;
  case ImageBase::CM_Bayer_GBRG :
    indexG = 0;
    offsetR = width;
    offsetB = +1;
    break;
  case ImageBase::CM_Bayer_GRBG :
    indexG = 0;
    offsetR = +1;
    offsetB = width;
    break;
  default :
    BIASERR("unknown bayer");
    return false;
    break;
  }

  unsigned char* sinkPixels = out.GetImageData();  
  unsigned char* grabedPixels = in.GetImageData();

  for(unsigned int j = 0; j < sinkHeight; j++) {
    for(unsigned int i = 0; i < sinkWidth; i++) {
      // R
      sinkPixels[index++] = grabedPixels[indexG+offsetR];
      // G
      sinkPixels[index++] = grabedPixels[indexG];
      // B
      sinkPixels[index++] = grabedPixels[indexG+offsetB];
      indexG += 2;
    }//end of over width
    indexG += width;
  }//end of over height

  return true;
}