ConvertHDR.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 "ConvertHDR.hh"
#include <Base/Image/ImageConvert.hh>
#include <Base/Debug/LogFacility.hh>

using namespace BIAS;
using namespace std;

namespace BIAS {

/**
 This class handles special conversions for HDR images
 @author Anne Sedlazeck
 @date feb 2009
 */
template<class StorageType>
ConvertHDR<StorageType>::ConvertHDR(){

}

template<class StorageType>
ConvertHDR<StorageType>::~ConvertHDR(){

}

/** simple conversion to unsigned char, assumed bit depth is 16 -> all pixel values are divided by 65535
 *  supports unsigned short int images.
 *  deprecated, use other method
 */
template<class StorageType> int ConvertHDR<StorageType>::ToUnsignedChar(
                                                                        BIAS::Image<
                                                                            StorageType>& src,
                                                                        BIAS::Image<
                                                                            unsigned char>& dst){

  ImageBase::EStorageType targetST = ImageBase::ST_unsignedchar;

  if (!dst.IsEmpty())
    dst.Release();
  dst.Init(src.GetWidth(), src.GetHeight(), src.GetChannelCount(), targetST);
  dst.SetROI(*src.GetROI());
  if (targetST == src.GetStorageType()) {
    dst = src;
    return 0;
  }

  dst.SetColorModel(src.GetColorModel());

  switch (src.GetStorageType()) {
    case ImageBase::ST_float:
    {
      unsigned int values = src.GetPixelCount() * src.GetChannelCount();
      unsigned char *d = (unsigned char*)dst.GetImageData();
      float *s =(float*) src.GetImageData();
      for (unsigned int i=0; i<values; i++){
        d[i] = (unsigned char) *s;
        s ++;
      }
    }
      break;
#ifdef BUILD_IMAGE_USHORT
      case ImageBase::ST_unsignedshortint:
      {
        unsigned int values = src.GetPixelCount() * src.GetChannelCount();
        unsigned char *d = (unsigned char*)dst.GetImageData();
        unsigned short int *s =(unsigned short int*) src.GetImageData();
//        StorageType minVal, maxVal;
//        src.GetMinMaxPixelValue(minVal, maxVal,0);
//        cout << "min " << minVal << " max " << maxVal << endl;
//        src.GetMinMaxPixelValue(minVal, maxVal,1);
//        cout << "min " << minVal << " max " << maxVal << endl;
//        src.GetMinMaxPixelValue(minVal, maxVal,2);
//        cout << "min " << minVal << " max " << maxVal << endl;

        BIASWARN("Conversion from unsigned short int to unsigned char by cast only!!!");
        for (unsigned int i=0; i<values; i++)
        d[i] = (unsigned char) (s[i]/65535.0*255.0);
      }
      break;
#endif // BUILD_IMAGE_SHORT
    default:
      BIASERR("ConvertHDR() not fully implemented "<<src.GetStorageType());
      BIASABORT;
      return -1;
  }
  return 0;

}

/** Conversion to unsigned char image, leaves min/max part intact.
 * @param gamma = gamma value for gamma correction (gamma = 1 means no gamma correction)
 * @param currentMaxVal = current maximun possible value - caused by bit depth for example bit depth 12 means a currentMaxVal of 4095
 * the actual min and max values of the image are incorporated, meaning, the image is not stretched to fill the whole range of values
 * between 0 and 255.
 */
template<class StorageType> int ConvertHDR<StorageType>::ToUnsignedCharGamma(BIAS::Image<StorageType>& src,
                                                                             BIAS::Image<unsigned char>& dst,
                                                                             float gamma, unsigned int currentMaxVal){


  ImageBase::EStorageType targetST = ImageBase::ST_unsignedchar;

  // prepare dst image
  if (!dst.IsEmpty())
    dst.Release();
  dst.Init(src.GetWidth(), src.GetHeight(), src.GetChannelCount(), targetST);

  dst.SetROI(*src.GetROI());

  // if dst image is already unsigned char don't do anything
  if (targetST == src.GetStorageType()) {
    dst = src;
    return 0;
  }


  // build float image to get started
  Image<float> fImage;
  ImageConvert::ConvertST(src, fImage, ImageBase::ST_float);

  // find min and max val across all channels
  float maxVal = 0, minVal=FLT_MAX, maxValTmp, minValTmp;
  for(unsigned short int ch = 0; ch < fImage.GetChannelCount(); ch++){
    fImage.GetMinMaxPixelValue(minValTmp, maxValTmp, ch);
    if(minValTmp < minVal){
      minVal = minValTmp;
    }
    if(maxValTmp > maxVal){
      maxVal = maxValTmp;
    }
  }

  BLD("convertHDR - maxVal is " << maxVal << " highestVal is " << currentMaxVal << endl);

  // scale image between 0 and 1 consistent to current value range
  fImage.ScaleShiftBetween(minVal/(float)currentMaxVal, maxVal/(float)currentMaxVal);


  dst.SetColorModel(fImage.GetColorModel());

  unsigned int values = fImage.GetPixelCount() * fImage.GetChannelCount();
  unsigned char *d = (unsigned char*)dst.GetImageData();
  float *s =(float*) fImage.GetImageData();
  float gammaVal;
  for (unsigned int i=0; i<values; i++){
    gammaVal =  pow((*s), gamma);
    d[i] = (unsigned char) (gammaVal*255);
    s ++;
  }

  return 0;

}



#define INST(type) template class ConvertHDR<type>;
INST(float)
INST(unsigned char)

#ifdef BUILD_IMAGE_USHORT
INST(unsigned short)
#endif

// yet untest inits

// #ifdef BUILD_IMAGE_INT
// INST(int);
// #endif
// #ifdef BUILD_IMAGE_CHAR
// INST(char);
// #endif
// #ifdef BUILD_IMAGE_SHORT
// INST(short);
// #endif
// #ifdef BUILD_IMAGE_USHORT
// INST(unsigned short);
// #endif
// #ifdef BUILD_IMAGE_USHORT
// INST(unsigned int);
// #endif
// #ifdef BUILD_IMAGE_DOUBLE
// INST(double);
// #endif

} // namespace BIAS