OpenEXRInterface.hh

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

#ifndef _OPENEXRINTERFACE_hh_
#define _OPENEXRINTERFACE_hh_


#include "bias_config.h"
#ifdef BIAS_HAVE_OPENEXR
#  ifdef WIN32
#    pragma warning( push, 1)
#    define PLATFORM_WINDOWS
#  endif // WIN32
#    include <ImfPixelType.h>
#    include <ImfCompression.h>
#    include <ImfHeader.h>
#    include <ImfFrameBuffer.h>
#    include <half.h>
#  ifdef WIN32
#    pragma warning( pop)
#  endif // WIN32
#endif

#include "ImageBase.hh"
#include <map>

namespace BIAS {

  /** Methods for reading and writing OpenEXR files into and from BIAS ImageBase.
  *
   * \attention Not all color models have been implemented, have a look at GenerateChannelNames_() method.
   *
   * If an EXR image is loaded without the new BIAS attributes the color model is chosen by means of the 
   * channel count, and defaults to the most common "intensity" based color models (i.e. Grey, RGB, RGBA). 
   * \attention If an EXR image is loaded that has channels of differing pixel type (e.g. one HALF and one UINT channel) 
   * FLOAT is chosen to be the common pixel type.
   *
   * Since no unsigned char images are natively supported by OpenEXR the BIAS StorageType is also stored in an exported
   * EXR image. This stored type is then used to chose the resulting ImageBase:EStorageType, when loading the image, overriding
   * derived types. This behaviour is not optimal in any case, however most of our tools will expect Image<unsigned char>, when 
   * this has been the original source's type.
   *
   * This is also not a full fledged implementation of all OpenEXR capabilties (i.e. Layers, Tiles, etc.).
   *
   * \author bartczak 02/2009
   **/
  class BIASImageBase_EXPORT OpenEXRInterface {
  public :
    OpenEXRInterface();
    ~OpenEXRInterface();

    int Export(const std::string& FileName,
               const ImageBase& input,
               const Imf::Compression& compression = Imf::ZIP_COMPRESSION);

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

    /** When exporting image this pixel type is used, not a derived one! 
    * Imf::HALF, Imf:FLOAT, Imf::INT are valid values.
    **/
    void SetOverridePixelTypeEXR(Imf::PixelType overridePT);

  protected:

    /** Used to maintain control of the heap when generating slices.
    **/
    class ChannelData {
    public:
      ChannelData() : ifFloat_(NULL), ifHalf_(NULL), ifUInt_(NULL) {};
      ChannelData(float* ifFloat) : ifFloat_(ifFloat), ifHalf_(NULL), ifUInt_(NULL) {};
      ChannelData(half* ifHalf) : ifFloat_(NULL), ifHalf_(ifHalf), ifUInt_(NULL) {};
      ChannelData(unsigned int* ifUInt) : ifFloat_(NULL), ifHalf_(NULL), ifUInt_(ifUInt) {};
      
      void ClearData() {
        delete [] ifFloat_; 
        ifFloat_ = NULL;
        delete [] ifHalf_; 
        ifHalf_ = NULL;
        delete [] ifUInt_;
        ifUInt_ = NULL;
      }
      enum TypeID {isFloat=0, isHalf, isUInt, empty};
      TypeID Get(float*& ifFloat, half*& ifHalf, unsigned int*& ifUInt) const {
        ifFloat = ifFloat_; 
        ifHalf = ifHalf_; 
        ifUInt = ifUInt_;
        if(ifFloat!=NULL) return isFloat;
        if(ifHalf!=NULL) return isHalf;
        if(ifUInt!=NULL) return isUInt;
        return empty;
      }
    private:
      float* ifFloat_;
      half* ifHalf_;
      unsigned int* ifUInt_;

    };

    Imf::PixelType MapStorageType_(const ImageBase::EStorageType& st);
    ImageBase::EStorageType MapPixelType_(const Imf::PixelType& pt, const std::string& storageTypeString="");
    
    static int GenerateChannelNames_(const ImageBase::EColorModel& cm, 
                                    const unsigned int& numChannels,
                                    std::vector<std::string>& channelNames);

    int AddChannels_(const ImageBase::EColorModel& cm,
                     const ImageBase::EStorageType& st,                
                     Imf::Header& outHeader,
                     Imf::FrameBuffer& fb,
                     const ImageBase& input);


    int AddSlice_(Imf::PixelType pt, 
                  const int& exrwidth, 
                  const int& exrheight,
                  const std::string& channelName,
                  Imf::FrameBuffer& fb,
                  unsigned int channel = 0,
                  const ImageBase* input = NULL);

    void ClearChannels_();
    std::map<std::string, ChannelData> channels_;

    bool useOverridePT_;
    Imf::PixelType overridePT_;
    
  };

}


#endif