OpenEXRInterface.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 "OpenEXRInterface.hh"

#ifdef BIAS_HAVE_OPENEXR
#  ifdef WIN32
#    pragma warning( push, 1)
#    define PLATFORM_WINDOWS
#  endif // WIN32
#    include <half.h>
#    include <ImfRgbaFile.h>
#    include <ImfRgba.h>
#    include <ImfArray.h>
#    include <ImathBox.h>
#    include <ImfInputFile.h>
#    include <ImfOutputFile.h>
#    include <ImfChannelList.h>
#    include <ImfPixelType.h>
#    include <ImfStringAttribute.h>
#  ifdef WIN32
#    pragma warning( pop)
#  endif // WIN32
#endif



using namespace BIAS;
using namespace Imf;
using namespace Imath;
using namespace std;

OpenEXRInterface::
OpenEXRInterface() : useOverridePT_(false)
{}

OpenEXRInterface::
~OpenEXRInterface()
{
  ClearChannels_();
}

int OpenEXRInterface::Export(const std::string& FileName,
                             const ImageBase& input,
                             const Imf::Compression& compression)
{
  try{
  ImageBase::EColorModel cm = input.GetColorModel();
  ImageBase::EStorageType st = input.GetStorageType();
 
  int exrwidth  = input.GetWidth();
  int exrheight = input.GetHeight();

  Header outHeader(exrwidth, exrheight);
  outHeader.compression() = compression;

  stringstream sstr;
  BIASASSERT(input.GetMetaData() != NULL);
  input.GetMetaData()->WriteAscii(sstr);
  outHeader.insert("BIASMetaData", StringAttribute(sstr.str().c_str()));

  stringstream sstrCM;
  sstrCM << cm;
  outHeader.insert("BIASColorModel", StringAttribute(sstrCM.str().c_str()));

  stringstream sstrST;
  sstrST << st;
  outHeader.insert("BIASStorageType", StringAttribute(sstrST.str().c_str()));


  FrameBuffer fb;  
  
  AddChannels_(cm, st, outHeader, fb, input);
  

  OutputFile outFile(FileName.c_str(), outHeader);
  outFile.setFrameBuffer(fb);
  outFile.writePixels(exrheight);
  } catch (Iex::BaseExc &error_ )
    {
      BIASERR("Writing "<<FileName<<" with OpenEXR failed."<<endl
              <<"  Caught exception: "<<endl
              <<"  "<<error_.what()<<endl
              );
      return -2; // error
    }
  

  return 0;
}


Imf::PixelType OpenEXRInterface::MapStorageType_(const ImageBase::EStorageType& st)
{
  if(useOverridePT_) 
    return overridePT_;

  PixelType pt = Imf::FLOAT;
  switch(st) {
  case ImageBase::ST_unsignedchar :
    pt = Imf::HALF;
    break;
#ifdef BUILD_IMAGE_UINT
  case ImageBase::ST_unsignedint :
    pt = Imf::UINT;
    break;
#endif

  default:
    break;
  }
  return pt;
}

ImageBase::EStorageType 
OpenEXRInterface::MapPixelType_(const Imf::PixelType& pt, const string& storageTypeString)
{
  ImageBase::EStorageType  st = ImageBase::ST_float;
  
#ifdef BUILD_IMAGE_UINT
  if(pt == Imf::UINT) st = ImageBase::ST_unsignedint;
#endif
  if(!storageTypeString.empty()) {
    ImageBase::EStorageType stFromString;
    ImageBase::StringToStorageType(storageTypeString, stFromString);
    if(stFromString!=ImageBase::ST_invalid) st = stFromString;
  }
  
  return st;
}

/** The order of the channel names in the vector is also the order of channels in the ImageBase representation!
 * E.G. channelNames[0] = "B", channelNames[1] = "G", channelNames[2] = "R" means that the OpenEXR channel named "B" is assigned
 * to channel 0 in the ImageBase representation, while channel named "R" is found in ImageBase representation channel=2.
**/
int OpenEXRInterface::GenerateChannelNames_(const ImageBase::EColorModel& cm, 
                                            const unsigned int& numChannels,
                                            std::vector<std::string>& channelNames) 
{
  channelNames.clear();
  channelNames.reserve(numChannels);
  switch(cm) {
  case ImageBase::CM_invalid: 
    for(unsigned int c=0; c<numChannels; c++) {
      stringstream sstr;
      sstr.clear();
      sstr.str("");
      sstr<<c;
      channelNames.push_back(sstr.str());
    }
    break;
  case ImageBase::CM_Grey:
    channelNames.push_back("Grey"); break;
  case ImageBase::CM_RGB: channelNames.push_back("R"); channelNames.push_back("G"); channelNames.push_back("B"); break;
  case ImageBase::CM_BGR: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_YUYV422: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_UYVY422: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_YUV420P: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_YUV444: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_YUV411: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_HSV: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_HSI_OBS: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_DV: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_RGBA:
    channelNames.push_back("R");
    channelNames.push_back("G"); 
    channelNames.push_back("B");
    channelNames.push_back("A"); break;
  case ImageBase::CM_GreyA:
    channelNames.push_back("Grey");
    channelNames.push_back("A"); break;
  case ImageBase::CM_Bayer_RGGB:
    channelNames.push_back("Bayer"); break;
  case ImageBase::CM_Bayer_GBRG:
    channelNames.push_back("Bayer"); break;
  case ImageBase::CM_Bayer_GRBG:
    channelNames.push_back("Bayer"); break;
  case ImageBase::CM_Bayer_BGGR:
    channelNames.push_back("Bayer"); break;
  case ImageBase::CM_HSL: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_hsL: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_SymTensor2x2: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_BGRA: BIASERR("You have data to test this? Please implement!"); break;
  case ImageBase::CM_RGBE: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_PGR_XB3_F7M3_GBRG: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_DepthAndVariance: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_Disparity:
    channelNames.push_back("disparity"); break;
  case ImageBase::CM_Depth:
    channelNames.push_back("depth"); break;
  case ImageBase::CM_YUYV: BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_LUV:  BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_XYZ:  BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_I1I2I3:  BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_LAB:  BIASERR("You have data to test this? Please implement!"); return -1; break;
  case ImageBase::CM_DOES_NOT_EXIST: BIASERR("What the heck could have happened?"); return -1; break;
  }
  return 0;
}



int OpenEXRInterface::AddChannels_(const ImageBase::EColorModel& cm,
                                   const ImageBase::EStorageType& st,              
                                   Imf::Header& outHeader,
                                   Imf::FrameBuffer& fb,
                                   const ImageBase& input) 
{
  
  int width = input.GetWidth();
  int height = input.GetHeight();
  unsigned int numChannels = input.GetChannelCount();

  PixelType pt = MapStorageType_(st);
  vector<string> channelNames;
  if(GenerateChannelNames_(cm, numChannels, channelNames)!=0) {
    BIASERR("error"); 
    return -1;
  }
  
  for(unsigned int c=0; c<channelNames.size(); c++) {
    outHeader.channels().insert(channelNames[c].c_str(), Channel(pt));

    if(AddSlice_(pt, width, height, channelNames[c], fb, c, &input)!=0) {
      return -1;
    }    
   
  }
  
  return 0;
}

int 
OpenEXRInterface::AddSlice_(Imf::PixelType pt,   
                            const int& exrwidth, 
                            const int& exrheight,
                            const std::string& channelName,
                            Imf::FrameBuffer& fb,
                            unsigned int channel,
                            const ImageBase* input)
{

  Slice exrSlice;
  exrSlice.fillValue = 0.0;
  exrSlice.xSampling = 1;
  exrSlice.ySampling = 1;
  //   int C = 0;
  //   if(input != NULL)
  //     C = input->GetChannelCount();

  switch (pt)
    {
    case Imf::FLOAT:
      {
        float* pixelsFloat = new float[exrwidth * exrheight];
        channels_[channelName] = pixelsFloat;
        exrSlice.type = Imf::FLOAT;
        exrSlice.base = (char*) pixelsFloat;
        exrSlice.xStride = sizeof(*pixelsFloat) * 1;
        exrSlice.yStride = sizeof(*pixelsFloat) * exrwidth;

        if(input!=NULL) {
          ImageBase::GetChannel<float>(*input, channel, pixelsFloat);
        }
      }
      break;
    case Imf::HALF:
      {
        half* pixelsHalf = new half[exrwidth * exrheight];
        channels_[channelName] = pixelsHalf;
        exrSlice.type = Imf::HALF;
        exrSlice.base = (char*) pixelsHalf;
        exrSlice.xStride = sizeof(*pixelsHalf) * 1;
        exrSlice.yStride = sizeof(*pixelsHalf) * exrwidth;

        if(input!=NULL) {
          ImageBase::GetChannel(*input, channel, pixelsHalf);
        }
      }
      break;

    case Imf::UINT:
#ifdef BUILD_IMAGE_UINT
      {
        unsigned int* pixelsUInt = new unsigned int[exrwidth * exrheight];
        channels_[channelName] = pixelsUInt;
        exrSlice.type = Imf::UINT;
        exrSlice.base = (char*) pixelsUInt;
        exrSlice.xStride = sizeof(*pixelsUInt) * 1;
        exrSlice.yStride = sizeof(*pixelsUInt) * exrwidth;

        if(input!=NULL) {
          ImageBase::GetChannel(*input, channel, pixelsUInt);
        }
      }
#else
      BIASERR("unsigned integer type  for ImageBase is not active, find alternative storage type");
      return -1;
#endif
      break;

    default:
      BIASERR("unexpected disp store type!");
      return -1;
    }

  

  fb.insert(channelName.c_str(), exrSlice);

  return 0;
}

void OpenEXRInterface::ClearChannels_()
{
  map<string, ChannelData>::iterator it=channels_.begin();
  for(;it!=channels_.end();it++){
    it->second.ClearData();
  }
  channels_.clear();
}


int 
OpenEXRInterface::Import(const std::string& FileName, ImageBase& result)
{

  try
    {

      InputFile exrInputFile( FileName.c_str() );

      Box2i dw = exrInputFile.header().dataWindow();
      int exrwidth  = dw.max.x - dw.min.x + 1;
      int exrheight = dw.max.y - dw.min.y + 1;
      if(exrwidth == 0 || exrheight ==0 ) {
        BIASERR("empty image");
        return -1;
      }

      FrameBuffer fb;
      unsigned int numChannels = 0;
      PixelType commonPTType = Imf::UINT;
      const ChannelList& channels = exrInputFile.header().channels();
      for(ChannelList::ConstIterator i = channels.begin(); i!= channels.end(); i++) {
        PixelType ptchannel = i.channel().type;
        AddSlice_(ptchannel, exrwidth, exrheight, i.name(), fb);       
        if(numChannels==0) {
          commonPTType = ptchannel;
        } else {
          if(ptchannel == Imf::FLOAT) commonPTType = Imf::FLOAT;
          if(ptchannel == Imf::HALF && commonPTType == Imf::UINT) commonPTType = Imf::FLOAT;
          if(ptchannel == Imf::UINT && commonPTType == Imf::HALF) commonPTType = Imf::FLOAT;
        }

        numChannels++;
      }
      if(numChannels==0) {
        BIASERR("no channels");
        return -1;
      }

      exrInputFile.setFrameBuffer(fb);
      exrInputFile.readPixels(dw.min.y, dw.max.y);

      //check if we have a color model
      vector<string> biasChannelNames;
      ImageBase::EColorModel cm = ImageBase::CM_invalid;
      const StringAttribute* colormodel =
        exrInputFile.header().findTypedAttribute<StringAttribute>("BIASColorModel");
      if(colormodel != NULL) {       
        ImageBase::StringToColorModel(colormodel->value(), cm);
        GenerateChannelNames_(cm, numChannels, biasChannelNames);
        numChannels = biasChannelNames.size();
      }

      const StringAttribute* storagetype =
        exrInputFile.header().findTypedAttribute<StringAttribute>("BIASStorageType");
      string storagetypestr = "";
      if(storagetype != NULL) {        
       storagetypestr = storagetype->value();
      }
      //extend for stored storage type here:
      ImageBase::EStorageType st = MapPixelType_(commonPTType, storagetypestr);

      if(!result.IsEmpty())
        result.Release();
      result.Init(exrwidth, exrheight, numChannels, st, true);

      //read the different channels into the image
      float* dataFloat = NULL;
      half* dataHalf = NULL;
      unsigned int* dataUInt = NULL;
      if(colormodel != NULL) {
        for(unsigned int c=0; c<numChannels; c++) {
          map<string, ChannelData>::const_iterator it = channels_.find(biasChannelNames[c]);  
          if(it == channels_.end()) continue;
          switch(it->second.Get(dataFloat, dataHalf, dataUInt)) {
            case ChannelData::empty: continue; break;
            case ChannelData::isFloat: 
              ImageBase::SetChannel(result, c, dataFloat);
              break;
            case ChannelData::isHalf: 
              ImageBase::SetChannel(result, c, dataHalf);
              break;
            case ChannelData::isUInt:
#ifdef BUILD_IMAGE_UINT
              ImageBase::SetChannel(result, c, dataUInt);
#else
              BIASERR("unsigned integer type  for ImageBase is not active, find alternative storage type");
              return -1;
#endif
              break;
          }//end of switch
        }//end of for each channel
      } else {
        unsigned int c=0;
        for(map<string, ChannelData>::const_iterator it=channels_.begin(); it!=channels_.end(); it++) {
          switch(it->second.Get(dataFloat, dataHalf, dataUInt)) {
            case ChannelData::empty: continue; break;
            case ChannelData::isFloat: 
              ImageBase::SetChannel(result, c, dataFloat);
              break;
            case ChannelData::isHalf: 
              ImageBase::SetChannel(result, c, dataHalf);
              break;
                 case ChannelData::isUInt:
#ifdef BUILD_IMAGE_UINT
         ImageBase::SetChannel(result, c, dataUInt);
#else
              BIASERR("unsigned integer type for ImageBase is not active, find alternative storage type");
              return -1;
#endif
              break;
          }//end of switch
          c++;
        }//end of for each channel
      }//end of else BIASColorModel Given

      if(cm==ImageBase::CM_invalid) {//guess color model if non available
        if(numChannels==1) cm=ImageBase::CM_Grey;
        if(numChannels==2) cm=ImageBase::CM_GreyA;
        if(numChannels==3) cm=ImageBase::CM_RGB;
        if(numChannels==4) cm=ImageBase::CM_RGBA;
      }
      result.SetColorModel(cm);
      //load meta data
      const StringAttribute* metadata =
        exrInputFile.header().findTypedAttribute<StringAttribute>("BIASMetaData");
      if(metadata != NULL) {
        stringstream sstr;
        sstr<<metadata->value();        
        sstr>> *result.GetMetaData();
      }
      if(exrInputFile.header().lineOrder() == Imf::DECREASING_Y) result.Flip();
    }
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  catch (Iex::BaseExc &error_ ) {
    BIASWARN("Reading "<<FileName<<" with OpenEXR failed."<<endl
             <<"  Caught exception: "<<endl
             <<"  "<<error_.what()<<endl
             );
#else
    catch (Iex::BaseExc &/*error_*/ ) {
#endif
      return -1; // error
    }
    catch (...){
      return -2;
    }

  
    return 0;
  }

  void OpenEXRInterface::SetOverridePixelTypeEXR(Imf::PixelType overridePT) 
  {
    overridePT_ = overridePT;
    useOverridePT_ = true;
  }