ImageIO.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 */
//#define ImageIO_DEBUG_IO

#include "ImageIO.hh"
#include <Base/Common/FileHandling.hh>

#ifndef WIN32
#include <unistd.h> // for usleep
#include <sys/stat.h>
#endif

// ImageMagick support
#ifdef BIAS_HAVE_IMAGEMAGICKLIB
#  include <Base/Common/BIASpragmaStart.hh>
#  include <Magick++.h>
#  include <Base/Common/BIASpragmaEnd.hh>
#  if (MagickLibVersion >= 0x650)
#    define MagickLib MagickCore
#  endif
#endif

// LibJPEG support: Sandro Esquivel 05/2008
#ifdef BIAS_HAVE_LIBJPEG
#  include "CompressJpeg.hh"
#endif

// required in header (not only cpp)
// due to public EXR PrintHeader interface
#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>
#    include "OpenEXRInterface.hh"
#  ifdef WIN32
#    pragma warning( pop)
#  endif // WIN32
#endif


#ifdef BIAS_HAVE_OPENCV
#  include "WrapBias2Ipl.hh"
#  include <cv.h>
#  include <highgui.h>
#endif

// use DevIL il with ilu (if DevIL is used at all)
#define USE_DEVIL_ILU

#ifdef BIAS_HAVE_DEVIL
#  include <IL/il.h>
#  ifdef USE_DEVIL_ILU
#    include <IL/ilu.h>
#  endif // USE_DEVIL_ILU
//#  include <IL/ilut.h>
#endif


#ifdef BIAS_HAVE_TIFF
#  include <tiffio.h>
// check TIFF version from tiffvers.h
#  if TIFFLIB_VERSION < 20051230
#    error You need at least TIFF version 3.8.0 (TIFFLIB_VERSION >= 20051230) for muli plane tiff.
#  endif
#endif


#include <Base/Debug/DebugSimple.hh>

#ifdef BIAS_DEBUG
#  include <Base/Debug/TimeMeasurement.hh>
#  include <Base/Debug/LogFacility.hh>
#endif // BIAS_DEBUG

#include <fstream>
#include <sstream>

#include "ImageConvert.hh"
#include "ViffHeader.hh"

// for transfrom:
#include <algorithm>
#include <cctype>

// for O_APPEND
#include <fcntl.h>

// for perror
#include <stdio.h>

//replace old ImageMagick-namespace with new one
#ifdef BIAS_IMAGEMAGICKLIB_V2
#  define MagickLib MagickCore
#endif //BIAS_IMAGEMAGICKLIB_V2


using namespace BIAS;
using namespace std;

char *ImageIO::MemAlignedBuffer_ = NULL;
unsigned long int ImageIO::MemAlignedBufferSize_ = 0;


/// helper function for ExtensionName type casting @author Jan Woetzel
char myTolower(char c) {
  return char(tolower(c));
}

// try to Read MIP image and if that fails try all import functions.
int ImageIO::
Load(const string& FileNameConst, ImageBase &img)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  string FileName; // (FileNameConst); // non const copy for tilde expansion
  FileHandling::FilenameExpansion(FileNameConst, FileName); // tilde

  int result = 0;

  ifstream is;
  is.open( FileName.c_str() );
  char identifier[IDENTIFIER_LENGTH];

  if (!is || !is.good()){
    // file does not exist/is not readable!
#if defined(BIAS_DEBUG) || defined(ImageIO_DEBUG_IO)
    BIASWARN("could not open fstream for file "<<FileName<<" with cwd="<<FileHandling::GetCwd());
#endif
    result = -1;
  } else {
    is.read(identifier, IDENTIFIER_LENGTH);
    if (!is.good()){
      result = -2;
      is.close();
    } else {
      if (identifier[0] == 'M' && identifier[1] == 'I' &&
        identifier[2] == 'P'){ // mipimage
          is.close();
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
          COUT("MIP format detected\n");
#endif

          result = Read_(FileName, img);
      } else {
        // foreign image format
        is.close();
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
        COUT("image not in mip format\n");
#endif
        result = ImageIO::ImportImage(FileName, img);
      }
    }
  }

  return result;
}


#ifdef BIAS_HAVE_IMAGEMAGICKLIB
int ImageIO::
ImportMagickPP(const std::string& FileName,
                                ImageBase& result,
                                const bool & /*dummy*/,
                                const bool & readMetaData )
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

#ifdef WIN32
  //initialize DLL loaded library (not required on Linux but once on Windows)
  Magick::InitializeMagick(NULL);
#endif

  Magick::Image image;
  image.read( FileName );

  return ImageConvert::ImageMagick2BIAS(image,result);
  if (readMetaData) {
    //#ifdef BIAS_DEBUG
    //BIAS::TimeMeasurement tm1("DBG get meta data inside ImportMagickPP ");
    //#endif // BIAS_DEBUG

    /*
            \TODO: crashes due to problem with const reference streaming !
            e.g. on loading ibak "M34/Front/image00000000.jpg"
            get the meta data from the (ASCII) comment field
            string copy required because you canot directly stream a const
            references!
            - postpones the crash, but on leaving the scope it crashes, too.
            MetaData operator<< problem?
            \bug Only crash under windows in certain special cases: Needs to be compiled outside the bias library and needs to be run in the debugger of visual studio .net 2003  to reproduce crash. Maybe different libraries are used in this case? Even in that case it only crashes when the argument result  is of type Image<unsigned char>. When result is of type ImageBase, it does not crash.  In all other cases (linux and windows without .net) it works correctly. Neither valgrind nor efence (linux) find any suspicous  activity here. MetaData.operator<< is *NOT* present in callstack. Maybe, buggy STL under windows?
     */
    string sTmp = image.comment();
    stringstream strstr; // see above
    strstr << sTmp;
#ifdef BIAS_DEBUG
    // BLD("ImageIO::ImportMagickPP() : Read image.comment() =  " << sTmp);
#endif
    BIASASSERT(result.GetMetaData() != NULL);
    strstr >> *(result.GetMetaData());
    // [HACK] esquivel:
    // Workaround to add simple comments to metadata. Comments consisting
    // of an unformated ascii string are added to metadata tag #[Comment].
    if (!image.comment().empty() && result.GetMetaData()->size() == 0) {
#ifdef BIAS_DEBUG
        // BLD("Image comment was not added, add tag #[Comment] explicitely.");
#endif
        result.GetMetaData()->Add("#[Comment]", image.comment());
    }
#ifdef BIAS_DEBUG
    //result.GetMetaData()->Dump();
#endif
  }

  return BIAS_IO_SUCCESS;
}
#endif // BIAS_HAVE_IMAGEMAGICKLIB


#ifdef BIAS_HAVE_OPENCV

int ImageIO::
ImportOpenCV(const std::string &filename, ImageBase &image)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  IplImage* p_cv = cvLoadImage(filename.c_str(), 1);
  if (p_cv == NULL) {
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    BIASERR("Reading image from " << filename << " with OpenCV failed!");
#endif
    return -1;
  }

  // convert IPL image from BGR to RGB color space for consistency reasons
  if (p_cv->nChannels == 4) {
    cvCvtColor(p_cv, p_cv, CV_BGRA2RGBA);
    strcpy(p_cv->channelSeq, "RGBA");
  } else if (p_cv->nChannels == 3) {
    cvCvtColor(p_cv, p_cv, CV_BGR2RGB);
    strcpy(p_cv->channelSeq, "RGB");
  }

  // copy IPL image into BIAS image data
  int res = BIAS::WrapBias2Ipl::CreateBiasImageCopy(p_cv, image);
  cvReleaseImage(&p_cv);
  return res;
}

int ImageIO::
ExportOpenCV(const std::string &filename, const ImageBase &image)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  IplImage* p_cv = NULL;
  int res = BIAS::WrapBias2Ipl::CreateIplImageShared(&image, p_cv);
  if (res == 0) {
    // convert IPL image from BGR to RGB color space for consistency reasons
    if (p_cv->nChannels == 4) {
      cvCvtColor(p_cv, p_cv, CV_BGRA2RGBA);
      strcpy(p_cv->channelSeq, "RGBA");
    } else if (p_cv->nChannels == 3) {
      cvCvtColor(p_cv, p_cv, CV_BGR2RGB);
      strcpy(p_cv->channelSeq, "RGB");
    }
    if (cvSaveImage(filename.c_str(), p_cv) == 0) {
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
      BIASERR("Writing image to " << filename << " with OpenCV failed!");
#endif
      res = -1;
    }
    // swap channels back into original order
    if (p_cv->nChannels == 4)
      cvCvtColor(p_cv, p_cv, CV_BGRA2RGBA);
    else if (p_cv->nChannels == 3)
      cvCvtColor(p_cv, p_cv, CV_BGR2RGB);
  }
  return res;
}

#endif // BIAS_HAVE_OPENCV


#ifdef BIAS_HAVE_OPENEXR
/** Print header information to stream
helper function
@author Jan Woetzel 09/2005 */
int PrintInfoEXR(const Imf::RgbaInputFile & f, std::ostream & os)
{
  using namespace Imf;
  using namespace Imath;
  os<<"OpenEXR header information: "<<endl;
  os<<"version:         "<<f.version()<<endl;
  //os<<"isComplete:      "<<f.isComplete()<<endl;

  // (meta) header
  const Imf::Header * h = &f.header();
  BIASASSERT(h!=NULL);
  // data windows
  Box2i dw = f.dataWindow();

  os<<"hasPreviewImage: "<<h->hasPreviewImage()<<endl;
  os<<"pixelAspectRatio:"<<h->pixelAspectRatio()<<endl;
  // OpenEXR can handle special image coordinate systems.
  os<<"dw dim: "<<dw.max.x - dw.min.x + 1
    <<" x "
    <<dw.max.y - dw.min.y + 1
    <<endl;
  os<<"  dw.x: "<<dw.min.x<<".."<<dw.max.x <<endl;
  os<<"  dw.y: "<<dw.min.y<<".."<<dw.max.y <<endl;

  return BIAS_IO_SUCCESS;
}



int ImageIO::
ExportOpenEXR(const std::string& FileName, const ImageBase& img)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif
  OpenEXRInterface interfaceEXR;
  return interfaceEXR.Export(FileName, img);
}

int ImageIO::
ImportOpenEXR(const std::string& FileName, ImageBase& result)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif
  OpenEXRInterface interfaceEXR;
  return interfaceEXR.Import(FileName, result);
}

#endif // BIAS_HAVE_OPENEXR


int ImageIO::
ImportImage(const string& filename, ImageBase &result )
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  int res=-1; // init as file not read
  ifstream ifs;
  unsigned char tmpline[512];

#ifdef   WIN32
  ifs.open(filename.c_str(),ios::binary);
#else  //not WIN32
  ifs.open(filename.c_str());
#endif //WIN32

  if (!ifs) {
    BIASERR("ImportImage(): open of file \""<<filename<<"\" failed");
    perror(filename.c_str());
    ifs.close();
    return -1;
  }

  // invalidate old uid, since it may refer to a different image
  result.InvalidateUID();

  // read first two chars to get a hint what this file is
  ifs >>tmpline[0]>>tmpline[1];
  if (!ifs){
    res=-1;
    BIASERR("unable to read from "<<filename);
    ifs.close();
    return res;
  }

  // Check for famous P5/P6 in PNM, PGM, PBM to determine the fileformat
  // and call our own reader if appropriate.
  if (tmpline[0] =='P' && tmpline[1] == '5') {
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    COUT("reading single channel pnm/pgm/pbm image using ImportImagePnm_\n");
#endif
    res = ImportImagePnm_(ifs, result, 1);
    if (res!=BIAS_IO_SUCCESS)
      BIASERR("error reading "<<filename<<" although P5 format detected.");
    result.SetColorModel(ImageBase::CM_Grey);
  } else if (tmpline[0] =='P' && tmpline[1] == '6') {
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    COUT("reading 3 channel pnm/pgm/pbm image using ImportImagePnm_\n");
#endif
    res = ImportImagePnm_(ifs, result, 3);
    if (res!= BIAS_IO_SUCCESS)
      BIASERR("error reading "<<filename<<" although P6 format detected.");
    result.SetColorModel(ImageBase::CM_RGB);
  }

  // other loaders do not use file stream but operate on filename directly
  // and open theirselves.
  ifs.close();

  //
  // Try to read using external image loaders.
  //
  //try matlab
  if(res!=BIAS_IO_SUCCESS)
    res = ImportMatrix(filename,result,false);
  // try EXR
#ifdef BIAS_HAVE_OPENEXR
  if (res!=BIAS_IO_SUCCESS)
    res=ImportOpenEXR(filename, result);
#endif

#ifdef BIAS_HAVE_IMAGEMAGICKLIB
  if (res!=BIAS_IO_SUCCESS)
    res=ImportMagickPP(filename, result);
#endif

#ifdef BIAS_HAVE_DEVIL
  if (res!=BIAS_IO_SUCCESS)
    res=ImportDevIL(filename, result);
#endif

#ifdef BIAS_HAVE_LIBJPEG
  if (res!=BIAS_IO_SUCCESS)
    res=ImportLibJPEG(filename, result);
#endif

#ifdef BIAS_HAVE_OPENCV
  if (res!=BIAS_IO_SUCCESS)
    res=ImportOpenCV(filename, result);
#endif

  //#ifdef BIAS_HAVE_RADIANCE
  if (res!=BIAS_IO_SUCCESS)
    res=ImportRADIANCE(filename, result);
  //#endif

  // try to read RAW4096/RAW04096/RAW0nnnn format
  if (res!=BIAS_IO_SUCCESS)
    res=ImportRAWwithHeader(filename, result);

#ifdef WIN32 // winapi
  if (res!=BIAS_IO_SUCCESS)
    res=Import_BITMAP_winapi(filename, result);
#endif

  /*
    \bug incorrectly loads .bmp occasionally
    due to too simple header parsing
    e.g. Ibak Beton1200_Front47.bmp !
    try to read VIFF if anything else failed
    this is last try because the routine is buggy. 
  */
  if (res!=BIAS_IO_SUCCESS) {
    // open fstream
    std::ifstream ifs(filename.c_str(), std::ios::binary );
    if (!ifs) {
      BIASERR("could not open "<<filename);
    } else {
      // OK
      res=ImportImageViff_(ifs, result );
    }
  }


  if (res==0){
    // --- handle meta data ----------------
    AppData ad;
    if (result.GetMetaData()->Find(AppData::MD_UUID,"#[UUID]", ad)>=0){
      if (ad.tag==AppData::MD_USE_ASCII){
        //cerr << "before |"<< ad.sdata <<"|"<< endl ;
        while (ad.sdata.length()>0 && (ad.sdata[0]=='#' || ad.sdata[0]==' ' ||
                                       ad.sdata[0]=='\n'))
          ad.sdata.erase(0, 1);
        if (ad.sdata.length()>36)
          ad.sdata.erase(36, ad.sdata.length()-36);
        //cerr<<"after |"<<ad.sdata<<"|"<<" length: "<<ad.sdata.length()<<endl;
        UUID TempID(ad.sdata);
        result.SetUID(TempID);
      } else {
        BIASERR("UUID is no meta datum in binary images");
        BIASERR("possibly two concurrent UUIDs in one image");
        //result.SetUID(*((UUID*)ad.data));
        //BIASASSERT(false);
        BIASABORT;
      }
    } else {
#ifdef BIAS_DEBUG
#  ifdef BIAS_EXTRA_WARN
      BIASERR("warning, no valid UID read, UUID must be set manually");
#  endif
#endif
      result.InvalidateUID();
    }
    //cerr <<"header in ImportImage"<<endl;
    //result.PrintHeader(cout);
  }
  return res;
} // ImportImage


#ifdef BIAS_HAVE_LIBJPEG
int ImageIO::
ImportLibJPEG(const string& filename, ImageBase &result,
              bool readComment)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  // Release result first
  if (!result.IsEmpty()){
    result.Release(true);
  }

  // Data structures
  int res = 0;
  BIAS::JpegHandler jHandler;
  BIAS::Image<unsigned char> image;
  jHandler.SetVerbose(false);
  res = jHandler.Init();
  if (res == 0) {
    res = jHandler.ReadJPEG(filename);
  }
  if (res == 0) {
    res = jHandler.Decompress(image, readComment);
  }
  jHandler.Release();

  // Apply image to result
  if (res == 0) {
    result = image;
  }
  return (res == 0 ? BIAS_IO_SUCCESS : -1);
}
#endif


int ImageIO::ImportImagePnm_(ifstream& ifs, ImageBase &result, int depth)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  int xres=-1, yres=-1, maxval=-1, read=0;
  int res=0;
  char c;

  if (!result.IsEmpty()) result.Release(true);
  // start from the beginning and read line with P5 or P6
  ifs.seekg(0,ios::beg);

  ifs >> c;
  //  cout << "format " << c;
  if (c!='P'){
    BIASERR("invalid magic cookie");
    return -1;
  }
  ifs >> c;
  //cout << c << endl;
  if (c!='5' && c!='6'){
    BIASERR("invalid magic cookie");
    return -1;
  }

  // this allows an arbitary amount of whitespace in between the header
  while (read<3){
    ifs >> c;
    ifs.putback(c);
    if (c=='#'){
      ifs >> *result.GetMetaData();
      if (!ifs){
        BIASERR("error reading meta data");
        return -1;
      }
    } else if (c>29 || c<40){ // number 0-9
      switch (read){
      case 0:
        ifs >> xres;
        //   cerr << "xres: "<<xres<<endl;
        read++;
        break;
      case 1:
        ifs >> yres;
        //      cerr << "yres: "<<yres<<endl;
        read++;
        break;
      case 2:
        ifs >> maxval;
        //    cerr << "maxval: "<<maxval<<endl;
        read++;
        break;
      default:
        BIASERR("funny error: "
                <<"there should be only 3 numerical values in pgm header");
        return -1;
        break;
      }; // switch
    } else { // if (c>29 || c<40){
      BIASERR("corrupted image header "<<c);
    }
  }
  ifs.read(&c, 1*sizeof(char)); // last whitespace

  //cerr <<"image has size "<<xres<<"x"<<yres<<"  with maxval "<<maxval<<endl;
  if (maxval==255){
#ifdef BIAS_DEBUG
    if (result.GetStorageType()!=ImageBase::ST_unsignedchar &&
        result.GetStorageType()!=ImageBase::ST_invalid){
      BIASERR("warning trying to load an unsigned char image into an image of"
              <<" storage type "<<result.GetStorageType());
      //BIASASSERT(false);
      BIASABORT;
    }
#endif
    result.Init(xres, yres, depth, ImageBase::ST_unsignedchar);
    ifs.read(reinterpret_cast<char *>(result.GetImageData()), xres * yres * depth);
  } else if (maxval==4095){ // 12 bit images
#ifdef BIAS_DEBUG
    if (result.GetStorageType()!=ImageBase::ST_unsignedshortint &&
        result.GetStorageType()!=ImageBase::ST_invalid){
      BIASERR("WARNING: Trying to load an unsigned short int image into an "
              <<"image of storage type "<<result.GetStorageType() << "!");
    }
#endif
    result.Init(xres, yres, depth, ImageBase::ST_unsignedshortint);
    result.SetBitDepth(12);
    ifs.read(reinterpret_cast<char *>(result.GetImageData()),
             sizeof(unsigned short int) * xres * yres * depth);
    // check if bytes need swapping
    unsigned short int *p=(unsigned short int *)result.GetImageData(), *pe;
    pe=p+result.GetPixelCount()*result.GetChannelCount();
    // check if pixel > maxval exist
    bool swap=false;
    while (p<pe) { swap = (swap || (*p > maxval)); p++; }
    // swap bytes if pixel > maxval existed
    if (swap){
      BIASERR("Max. value > "<<maxval<<" : Swapping LSB and MSB!");
      char *cp=(char *)result.GetImageData(), *cpe;
      cpe=(char *)((unsigned short int *)cp + result.GetPixelCount()*
                   result.GetChannelCount());
      char c;
      while (cp<cpe){
        c=cp[0]; cp[0]=cp[1]; cp[1]=c;
        cp+=2;
      }
    }
  } else if(maxval==65535){ // 16 bit images
#ifdef BIAS_DEBUG
    if (result.GetStorageType()!=ImageBase::ST_unsignedshortint &&
        result.GetStorageType()!=ImageBase::ST_invalid){
      BIASERR("WARNING: Trying to load an unsigned short int image into an "
              <<"image of storage type "<<result.GetStorageType()<<"!");
    }
#endif
    result.Init(xres, yres, depth, ImageBase::ST_unsignedshortint);
    result.SetBitDepth(16);
    ifs.read(reinterpret_cast<char *>(result.GetImageData()),
             sizeof(unsigned short int) * xres * yres * depth);
    // check if bytes need swapping
    unsigned short int *p=(unsigned short int *)result.GetImageData(), *pe;
    pe=p+result.GetPixelCount()*result.GetChannelCount();
    // check if pixel > maxval exist
    bool swap=true;
    while (p<pe) { swap = (swap || (*p > maxval)); p++; }
    // swap bytes if pixel > maxval existed
    if (swap){
      BIASERR("Max. value > "<<maxval<<" : Swapping LSB and MSB!");
      char *cp=(char *)result.GetImageData(), *cpe;
      cpe=(char *)((unsigned short int *)cp + result.GetPixelCount()*
                   result.GetChannelCount());
      char c;
      while (cp<cpe){
        c=cp[0]; cp[0]=cp[1]; cp[1]=c;
        cp+=2;
      }
    }
  }

  if (!ifs.good()){
    BIASERR("error reading from ifs");
    res=-1;
  }
  return res;
}


int ImageIO::
Save(const string& c_filename,
     const ImageBase &img_const,
     const enum TFileFormat c_FileFormat,
     const bool sync,
     const int c_jpeg_quality,
     const bool forceNewID,
     const bool & writeMetaData)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif
  bool TriedIt = false;

  ImageBase img(img_const);
  int result = -1;
#if defined(BIAS_HAVE_IMAGEMAGICKLIB) || defined(BIAS_HAVE_LIBJPEG)
  int quality = c_jpeg_quality;
#endif

  // non const to change for auto detection:
  TFileFormat FileFormat=c_FileFormat;
  if (FileFormat==FF_auto)
  {
    // determine by filename extension:
    FileFormat=GetFileFormat(c_filename);
    // if we couldn't determine BIAS FileFormat
    // give the external libs their own "low level" try
    if (FileFormat==FF_unknown)
        FileFormat=FF_auto;
  }

  // non const for adding suffix
  string filename(c_filename);
  FileHandling::FilenameExpansion (c_filename, filename); // tilde

  if (img.GetStorageType()==ImageBase::ST_invalid){
    BIASERR("cannot save images with StoragType ST_invalid. ");
    return -1;
  }

  // -----------------------------------------------------
  // -- UUID handling following the idea
  // -- if the image does not have a UUID we generate one that is written to disk.
  // Q: Shall the ID be assigned to the orig. image "by ref." too
  //    which results in a *non* const image?
  // A: Yes, we want the side effect of assigning the ID by reference,
  //    and not only to the local copy for disk only. (koeser, 12/Dec/2005)
  //    However, this behavior will change when we adopt the calling code
  //    to make img const.
  // changed, woelk 09/2006
  // -----------------------------------------------------

  // force a fresh UID
  if (forceNewID) {
    img.SetUID(UUID::GenerateUUID());
  }

  // append to metadataonly if newID forced or metadata is
  // really written to avoid side effect in the long run
  if (writeMetaData && (!img.GetUID().IsValid()))
  {
    // the image to be saved will become const some day
    BIASWARN("UUID assignment required. Please fix your code and assign a UID in the calling function if desired.");
    img.SetUID(UUID::GenerateUUID());
  }
  // write uuid to meta data if valid (only temporary to utilize metadata i/o)
  if (writeMetaData)
  {
    BIASASSERT( img.GetUID().IsValid() );
    string suuid;
    img.GetUID().GetString(suuid);
    img.GetMetaData()->Add("#[UUID]", suuid);
  }


  // -------------------------------------------------------------
  // ---  try to write with our internal format handlers, first.
  // -------------------------------------------------------------

  if (result!=BIAS_IO_SUCCESS)
  {
    // construct valid filename with appropriate extension
    switch (FileFormat)
    {
      case FF_auto:
      case FF_unknown:
        // leave the filename as it is for fmt detection by filename.
        break;
      case FF_mip:
        filename =ImageIO::ExtensionName( filename, GetExtension(FileFormat) );
        result = Write_(filename, img, sync, forceNewID);
        TriedIt = true;
        break;
      case FF_matrix:
        filename =ImageIO::ExtensionName( filename, GetExtension(FileFormat) );
        result = ExportMatrix(filename, img, false);
        TriedIt = true;
        break;
      case FF_pgm:
      case FF_ppm:
        {
          filename = ExtensionName( filename, GetExtension(FileFormat) );
          // use our internal impl. only for 8bit, 16 bit is impl. incorrectly
          if (img.GetDepth()==1) /* Byte per Channel */
            {
              if ((FileFormat==FF_pgm) && (img.GetChannelCount()!=1))
                {
                  // we need to convert:
                  Image<unsigned char> greyIMG(img);
                  ImageConvert::IP_ToGrey(greyIMG);
                  result = ExportImagePnm_(filename,greyIMG,sync,writeMetaData);
                  TriedIt = true;
                } else {
                // no slow conversion, is already correct fmt
                result = ExportImagePnm_(filename,img,sync,writeMetaData);
                TriedIt = true;
              };
            }
        }
        break;
      case FF_jpg:
        #if defined(BIAS_HAVE_IMAGEMAGICKLIB) || defined(BIAS_HAVE_LIBJPEG)
          filename = ImageIO::ExtensionName( filename, GetExtension(FileFormat) );
          if (c_jpeg_quality < 0 || c_jpeg_quality > 100)
            {
              BIASERR("The quality "<<c_jpeg_quality
                      <<" is out of valid range 0..100 % falling back to 100% full quality." );
              quality=100;
            }
        #else
          BIASERR("No JPEG support activated in BIAS. Switch on ImageMagick or LibJPEG in BIAS to enable jpeg support.");
        #endif


        break;
      //todo move writing raw4096 images from GrabApp here
      case FF_raw4096:
        BIASERR("writing raw4096 is not (yet) implemented in BIAS, only on WIN32 scorpion grab application.");
        return -7;
        break;
        // we could add our internal handlers for pnm, here.
        // however - the ImageMagic and DevIL versions
        // are more reliable, in particular for hdr formats.
      case FF_bmp:
      case FF_pbm:
      case FF_tif:
      case FF_png:
      case FF_viff:
      case FF_exr:
      case FF_dds:
        filename = ExtensionName( filename, GetExtension(FileFormat) );
        break;
      default:
        BIASERR("Unknown image file format for saving "<<c_filename<<" with format:"<<FileFormat<<" Nothing saved!");
        return -1;
      } // switch
  }

  // --------------------------------------------------
  // ---   Try to write using external libraries.   ---
  // --------------------------------------------------

  if (result!=BIAS_IO_SUCCESS) {
    if (FileFormat==FF_matrix) {
      result= ExportMatrix(filename,img,false);
    }
  }

#ifdef BIAS_HAVE_OPENEXR
  if (result!=BIAS_IO_SUCCESS) {
    // handle only those formats OpenEXR supports
    if (FileFormat==FF_exr) {
      result=ExportOpenEXR(filename, img );
      TriedIt = true;
    }
  }
#endif

#ifdef BIAS_HAVE_IMAGEMAGICKLIB
  // try to use ImageMagick++ library.
  if (result!=BIAS_IO_SUCCESS) {
    // skip the formats ImageMagick cannot handle,
    // at least those it claims to handle but is doing wrong things (e.g. dds)
    if ((FileFormat!=FF_dds) && (FileFormat!=FF_exr) &&
        (FileFormat!=FF_mip) && (FileFormat!=FF_raw4096))
    {
      result=ExportMagickPP (filename, img, quality, writeMetaData);
      TriedIt = true;
    }
  }
#endif

#ifdef BIAS_HAVE_DEVIL
  // try to use DevIL library
  if (result!=BIAS_IO_SUCCESS) {
    if ((FileFormat!=FF_exr) && (FileFormat!=FF_mip) &&
         (FileFormat!=FF_raw4096))
    {
      result=ExportDevIL(filename, img);
      TriedIt = true;
    }
  }
#endif

#ifdef BIAS_HAVE_LIBJPEG
  // try to use jpeg library
  if (result!=BIAS_IO_SUCCESS){
    if (FileFormat == FF_jpg) {
      result=ExportLibJPEG(filename, img);
      TriedIt = true;
    }
  }
#endif

#ifdef BIAS_HAVE_OPENCV
  // try to use OpenCV library
  if (result != BIAS_IO_SUCCESS) {
    result = ExportOpenCV(filename, img);
    TriedIt = true;
  }
#endif

  if (!TriedIt)
    BIASERR("Image not even tried to be written");

  // final result:
  return result;
}

#ifdef BIAS_HAVE_LIBJPEG
int ImageIO::
ExportLibJPEG(const std::string &filename,
              const BIAS::ImageBase &image,
              const int quality)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  if (quality < 0 || quality > 100) {
    BIASERR("Invalid quality " << quality << " given for JPEG compression!");
    return -1;
  }

  // Convert image to unsigned char
  BIAS::Image<unsigned char> image_UC;
  BIAS::ImageConvert::ConvertST(image, image_UC, ImageBase::ST_unsignedchar);

  // Data structures
  int res = 0;
  BIAS::JpegHandler jHandler;
  jHandler.SetVerbose(false);
  res = jHandler.Init();
  if (res == 0) {
    res = jHandler.Compress(image_UC, quality);
  }
  if (res == 0) {
    res = jHandler.WriteJPEG(filename);
  }
  jHandler.Release();

  return (res == 0 ? BIAS_IO_SUCCESS : -1);
}
#endif

int ImageIO::
ExportImagePnm_(const string &FileName,
                const ImageBase &img,
                bool sync,
                const bool & writeMetaData)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif
  ofstream ofs;
  // bool sync=false;

#ifdef   WIN32
  ofs.open(FileName.c_str(),ios::binary);
#else  //not WIN32
  ofs.open(FileName.c_str());
#endif //WIN32

  if (!ofs) {
    BIASERR("ExportImagePnm_() : open of file "<<FileName<<" failed");
    perror(FileName.c_str());
    return -1;
  }

#ifdef BIASDEBUG
  if (img.GetDepth()!=1)
    BIASERR(FUNCNAME <<" supports only 8 bit per Channel images. Please call "
            <<"ExportImage or Save instead.");
#endif // BIASDEBUG

  switch (img.GetChannelCount()) {
  case 3: // 8bit ppm
    ofs <<"P6"<<endl;
    break;

  case 1: // 8bit pgm
    ofs << "P5"<<endl;
    break;
  default:
    BIASERR("ExportImagePnm_() : unsupported number of channels: "<<
            img.GetChannelCount());
    return -1;
  }

  if (writeMetaData){
    img.GetMetaData()->WriteAscii(ofs);
    if (!ofs){
      BIASERR("writing MetaData failed");
      return -2;
    }
  };

  ofs << img.GetWidth()<<" "<<img.GetHeight()<<endl;
  ofs << "255"<<endl;

  ofs.write(reinterpret_cast<const char *>(img.GetImageData()), img.GetSizeByte());
  if(!ofs) {
    BIASERR("ExportImagePnm_() : write failed");
    return -1;
  }

  if (sync) {
    // flush streambuf from c++
    ofs.flush();
    // flush system buffers
#ifndef _WIN32
#  if __GNUC__ < 3
    fsync(ofs.rdbuf()->fd());
#  else
    ofs.rdbuf()->pubsync();
#  endif
#else // _WIN32
    ofs.rdbuf()->pubsync();
#endif //_WIN32
  }

  ofs.close();
  return 0;
}


std::string ImageIO::
ExtensionName(const std::string & oldName,
              const std::string & newExtension)
{
  string name    = oldName; // full name
  string ext     = FileHandling::Extension( oldName );
  string base     = FileHandling::DirectoryAndBasename(oldName );
  string newExtLC= FileHandling::LowerCase( newExtension );

  // catch empty file name:
  if (base.size()<1)
    base="out___"; // default

  // append extension if it is not the correct case insensitive extension:
  if (ext!=newExtLC) {
    name = base;
    if (name[name.size()-1] != '.')
        name+= ".";
    name+=newExtLC;
  }
  return name;
}


int ImageIO::
Write_(const string& FileName, const ImageBase &img_const,
       bool sync, bool forceNewID)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  int res = 0;
  ofstream os;

  ImageBase img(img_const);

  // assign new id if forced or there is none yet
  if ((forceNewID) || (!img.GetUID().IsValid())) {
    img.SetUID(UUID::GenerateUUID());
  }

  // avoid ".mip.mip" 
  string file = ImageIO::ExtensionName( FileName, "mip");

#ifdef   WIN32
  os.open(file.c_str(),ios::binary);
#else  //not WIN32
  os.open(file.c_str());
#endif //WIN32

  if (!os){
    string Errorstring="Error opening "+file+" writing";
    perror(Errorstring.c_str());
    return -1;
  }

  //write image
  os << img;

  res = (os.good())?(0):(-5);

  if (res==0){
    //cerr <<"Writing MetaData\n";
    //img.GetMetaData()->Dump();
    img.GetMetaData()->WriteBinary(os);
    if (!os){
      BIASERR("writing MetaData failed");
      res=-6;
    }
  }

  if (sync) {
    // flush streambuf from c++
    os.flush();
    // flush system buffers
#ifndef _WIN32
#  if __GNUC__ < 3 // in gcc 2.9x we can get a POSIX file descriptor
    fsync(os.rdbuf()->fd());
#  else   // in gcc 3.x this is prohibited :-(
    os.rdbuf()->pubsync();
    //     ::sync(); // this is systemcall sync() to sync all buffers
#  endif
#else // _WIN32
      /** @todo Sync written files and buffers to disk under WIN32
          (evers 2004-10-14) */
      //    os.rdbuf()->pubsync();
      //     ::sync();
#endif // _WIN32
  }
  os.close();

#ifndef _WIN32 // alternative way to sync, reopen file to get a handle
  int fd = open(file.c_str(),O_APPEND);
  fsync(fd); // and now fsync()
  close(fd);
#endif
  return res;
}


int ImageIO::
WriteRAW_IMA(const string& FileName, const ImageBase &img_const)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  int res = 0;
  ofstream os;

  //is a planar image!
  ImageBase img(img_const);
  if(img.IsInterleaved()) {
    BIASERR("need planar image!");
    return -1;
  }
  short intro = 0;
  short width = static_cast<short>(img.GetWidth());
  short height = static_cast<short>(img.GetHeight());
  short channels = static_cast<short>(img.GetChannelCount());
  unsigned char* pel = (unsigned char*)img.GetImageData();

  string file = ImageIO::ExtensionName( FileName, "ima");

  // #ifdef   WIN32
  //   os.open(file.c_str(),ios::binary);
  // #else  //not WIN32
  os.open(file.c_str(),ios::binary);
  // #endif //WIN32

  if (!os){
    string Errorstring="Error opening "+file+" writing";
    perror(Errorstring.c_str());
    return -1;
  }

  //  cout<<sizeof(short)<<endl;
  os.write((char*)&intro, sizeof(short));
  os.write((char*)&width, sizeof(short));
  os.write((char*)&channels, sizeof(short));
  for(unsigned int i=0; i<(unsigned int)width*height*3; i++) {
    unsigned char out = 255 - pel[i]  ;
    os.write((char*)&(out), sizeof(unsigned char));
    //     cerr<<i<<endl;
  }


  res = (os.good())?(0):(-5);

  os.close();

#ifndef _WIN32 // alternative way to sync, reopen file to get a handle
  int fd = open(file.c_str(),O_APPEND);
  fsync(fd); // and now fsync()
  close(fd);
#endif
  return res;
}

int ImageIO::
ImportMatrix(const std::string &FileName,
                         ImageBase &img, const bool verbose)
{
    if(FileHandling::Extension(FileName)!="matrix") return -1;

    if(verbose) cout<<"converting textfile to image matrix...\n";
    ifstream in(FileName.c_str());
    if (in.fail()) {
        BIASERR("could not load"<<FileName);
        return -2;
    }
    unsigned int rows,cols,cc, interleaved;
    in >> rows >> cols >> cc >> interleaved;

    if(verbose){
        cout<<"Rows:"<<rows<<" Cols:"<<cols
        <<" Channelcount:"<<cc<<" Interleaved:"<<interleaved<<"\n";
    }
    img.Init(cols, rows, 1, ImageBase::ST_float);
    float **data = (float**)img.GetImageDataArray();
    for (unsigned int h=0; h<rows; h++) {
        for (unsigned int w=0; w<cols; w++) {
            for (unsigned int c=0; c<cc; c++) {
                if(interleaved!=0) //interleaved case
                    in >> data[h][w*cc+c];
                else //planar case
                    in >> data[h+rows*c][w];
            }
        }
    }
    in.close();
    return 0;
}


int ImageIO::
ExportMatrix(const std::string &FileName,
        const ImageBase &ipic,const bool verbose)
{
    if(FileHandling::Extension(FileName)!="matrix") {
        return -1;
    }

    if(verbose) cout<<"converting image matrix to textfile...\n";
    if(ipic.GetChannelCount()!=1) {
        BIASERR("conversion only implemented for single channel images");
        return -2;
    }
    unsigned int rows,cols,cc, interleaved;
    rows = ipic.GetHeight();
    cols = ipic.GetWidth();
    cc = ipic.GetChannelCount();
    interleaved = ipic.IsInterleaved()?1:0;
    if(verbose)
        cout<<"Rows:"<<rows<<" Cols:"<<cols
        <<" Channelcount:"<<" interleaved:"<<interleaved<<cc<<"\n";
    //open file
    ofstream ofs(FileName.c_str());
    if(!ofs) {
        BIASERR("Could not open stream to "<<FileName);
        return -4;
    }
    ofs<<rows<<" "<<cols<<" "<<cc<<" "<<interleaved<<endl;


    if(ipic.GetStorageType() == ImageBase::ST_float)
    {
        float** imageDataArray = (float**)ipic.GetImageDataArray();

        for(unsigned int h = 0; h< rows; h++) {
            //image rows are matrix rows
            for(unsigned w = 0; w< cols; w++) {
                for(unsigned c = 0; c< cc; c++) {
                    if(interleaved!=0) //interleaved case
                        ofs<<imageDataArray[h][w*cc+c];
                    else //planar case
                        ofs<<imageDataArray[h+rows*c][w];
                    ofs<<" ";
                }
            }
            ofs<<endl;
        }
    } else if(ipic.GetStorageType() == ImageBase::ST_unsignedchar)
    {
        unsigned char** imageDataArray = (unsigned char**)ipic.GetImageDataArray();
        for(unsigned int h = 0; h< rows; h++) {
            //image rows are matrix rows
            for(unsigned w = 0; w< cols; w++) {
                for(unsigned c = 0; c< cc; c++) {
                    if(interleaved!=0) //interleaved case
                        ofs<<imageDataArray[h][w*cc+c];
                    else //planar case
                        ofs<<imageDataArray[h+rows*c][w];
                    ofs<<" ";
                }
            }
            ofs<<endl;
        }
    } else {
        BIASERR("Unsupported storage type of input image");
        return -3;
    }
    ofs.close();
    if (verbose) cout <<"done"<<endl;
    return 0;
}


int ImageIO::
Read_(const string& FileName, ImageBase &img)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif
  
  int res=0;
  ifstream is;

#ifdef   WIN32
  is.open(FileName.c_str(),ios::binary);
#else  //not WIN32
  is.open(FileName.c_str());
#endif //WIN32

  if (!is){
    string Errorstring="Error opening "+FileName+" for reading";
    perror(Errorstring.c_str());
    return -1;
  }
  is >> img;


  res = (is.good())?(0):(-5);

  if (res==0){
    // cerr << "ImageIO::Load() : "<<is.tellg()<<endl;
    is >> *img.GetMetaData();
    if (!is && !is.eof()){
      BIASERR("error reading MetaData");
      res = -6;
    }
  }

  //  img.GetMetaData()->Dump();

  is.close();


  return res;
}



int ImageIO::
ImportImageViff_(std::ifstream& ifs, ImageBase &result)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  /*class*/ xvimage viff;
  if (!ifs)
    return -1;
  if (!result.IsEmpty()) result.Release(true);
  ifs.seekg(0, ios::beg);

  // read header struct
  ifs.read((char*)&viff,sizeof(viff));
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  cout <<"read viff size "<<viff.row_size<<" x "<<viff.col_size<<endl;
#endif
  // too big viff image size usually means it is no viff image
  // and would blow memory 08/2005)
  const unsigned long maxUsefulDim=4096*2;
  const unsigned long minUsefulDim=8;
  if ( viff.row_size>maxUsefulDim
       || viff.col_size>maxUsefulDim
       || viff.row_size<minUsefulDim
       || viff.col_size<minUsefulDim
       )
    {
      // corrupt image?
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
      BIASERR(
              "viff image dim "<<viff.row_size<<"x"<<viff.col_size<<" is not useful(>"<<maxUsefulDim<<"),"<<endl
              <<"handling it as error. Skipping viff read. Adapt maxUsefulDim if you feel this behavior is wrong. "
              );
#endif
      return -1; // error
    }

  //   if (xres %4 >0) xresaligned = xres - xres%4;
  //   else xresaligned = xres;

  //result.Init(xresaligned, yres, depth, ImageBase::ST_unsignedchar);
  result.Init(viff.row_size, viff.col_size,
              1, ImageBase::ST_float); // 1 is the number of channels
  //  cerr << "initialized with " << xres << " " << yres
  // << " unsigned char" << endl;

  // read data area
  ifs.read(reinterpret_cast<char*>(result.GetImageData()), result.GetSizeByte());
  result.SetColorModel(ImageBase::CM_Grey);

  return 0;  // ok
}


#ifdef BIAS_HAVE_IMAGEMAGICKLIB
  /** @brief: This routine is working inefficiently,
      because it doesn't know what to do about conversion if read and requested
      types don't match (10/2004)
      However it works and assumes RGB in case of doubt.
      \todo rewrite by making more use of type Image<..> instead of ImageBase
      because lossless conversions and warnings for unwanted lossy conversions
      are easier, then.
      @author Jan Woetzel 10/2004 */
int ImageIO::
ImportMagickPPAutoconvert(const std::string& FileName,
                          ImageBase& result,
                          const bool &/*assumeGrey*/,
                          const bool &readMetaData )
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

#ifdef WIN32
  // initialize DLL loaded library (not required on Linux but once on Windows)
  Magick::InitializeMagick(NULL);
#endif

  try {

    Magick::Image image; // temporary converter for lib usage

    // Read a file into image object using Magick++ library function:
    image.read( FileName );

#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    COUT(
         "DBG Read "<<image.columns()<<"x"<<image.rows()<<" "
         <<image.magick()<<" image "
         <<FileName<<" using ImageMagick++"<<endl
         <<"  depth: "<<image.depth()<<" bit."<<endl
         <<"  comment: "<<endl<<image.comment()<<endl
         );
#endif

    // determine if import image format/channels and bit depth match:
    Magick::StorageType outputST=Magick::CharPixel; // output storage type

    /** keep the output storagetype
        \todo TODO HACK add dynamic cast test for templated Image<> to convert loaded float image automatically to uc etc..
        \todo add more knowledge about conversion and the option of errors if requested and read type don't match.
        check if at least StorageType and bit depth match:
    */
    //
    // first switch: ouput storagetype
    //
    switch (result.GetStorageType())
      {
      case BIAS::ImageBase::ST_invalid:
        BIASERR("invalid Storagetype ST_invalid FileName="<<FileName<<endl);
        break;

      case BIAS::ImageBase::ST_unsignedchar:
      case BIAS::ImageBase::ST_char:
        // 8 bit
        if (image.depth() != 8*sizeof(char)){
          BIASERR("StorageType is "<<8*sizeof(char)<<" bit but data has "<<image.depth()<<" bit depth. FileName="<<FileName<<endl);
          /** \todo handle conversion in extra routine
              with extra warnings in case of scaling or lossy conversion.
              -Add a 'normalized scale' per conversion for each Storagetype.
              -Add a flag to return errors instead of run-time warning. (discussion 26.Oct.2004)  */
          return -1;
        } else {
          outputST=Magick::CharPixel;
          COUT("is an "<<8*sizeof(char)<<" bit (u)char image\n");
        };
        break;

      case BIAS::ImageBase::ST_unsignedshortint:
      case BIAS::ImageBase::ST_shortint:
        // 16 bit
        if (image.depth()!=8*sizeof(short)){
          BIASERR("StorageType is "<<8*sizeof(short)<<" bit "
                  <<"but data has "<<image.depth()<<" bit depth. "
                  <<"FileName="<<FileName<<endl);
          return -2;
        } else {
          outputST=Magick::ShortPixel;
          COUT("is a "<<8*sizeof(short)<<" bit (u)short image\n");
        };
        break;

      case BIAS::ImageBase::ST_unsignedint:
      case BIAS::ImageBase::ST_int:
        // 32 bit int
        if (image.depth()==8*sizeof(int)){
          BIASERR("StorageType is "<<8*sizeof(int)<<" bit but data has "<<image.depth()<<" bit depth. FileName="<<FileName<<endl);
          return -3;
        } else {
          outputST=Magick::IntegerPixel;
          COUT("is a "<<8*sizeof(int)<<" bit (u)int image\n");
        };
        break;

        /**  \todo float and double pixel are 0..1 normalized range in ImageMagick++. Min, max meta data required */
      case BIAS::ImageBase::ST_float:
        // 32 bit float
        if (image.depth()!=8*sizeof(float)) {
          BIASERR("StorageType is "<<8*sizeof(float)<<" bit but data has "<<image.depth()<<" bit depth. FileName="<<FileName<<endl);
          return -4;
        } else {
          outputST=Magick::FloatPixel;
          COUT("is a "<<8*sizeof(float)<<" bit float image\n");
          BIASERR("warning: You are using ImageMagick to read a float image. Be aware that ImageMagick float values are normalized to 0..1 !!!"<<endl);
        };
        break;

      case BIAS::ImageBase::ST_double:
        // 64 bit double
        if (image.depth()!=8*sizeof(double)){
          BIASERR("StorageType is "<<8*sizeof(double)<<" bit but data has "<<image.depth()<<" bit depth. FileName="<<FileName<<endl);
          return -4;
        } else {
          outputST=Magick::DoublePixel;
          COUT("is a "<<8*sizeof(double)<<" bit float image\n");
          BIASERR("warning: You are using ImageMagick to read a double image. Be aware that ImageMagick float values are normalized to 0..1 !!!"<<endl);
        };
        break;

      default:
        BIASERR("StorageType "<<result.GetStorageType()<<" not supported. FileName="<<FileName<<endl);
        return -9; // error
      };


    //
    // second switch for channels: number and color model
    //
    string magickMap="RGB"; // default
    unsigned int nChannels=3;
    //determine import image format/channels:
    switch (result.GetColorModel()) {
    case BIAS::ImageBase::CM_invalid:
      COUT("DBG CM_invalid. Setting default map RGB\n");
      nChannels=3;
      magickMap="RGB";
      break;

    case BIAS::ImageBase::CM_Grey:
      COUT("DBG CM_Grey\n");
      magickMap="K"; // blacK=grey
      nChannels=1;
      break;
    case BIAS::ImageBase::CM_GreyA:
      //COUT("DBG CM_GreyA\n");
      magickMap="KA";
      nChannels=1;
      break;
    case BIAS::ImageBase::CM_RGB:
      //COUT("DBG CM_RGB\n");
      magickMap="RGB";
      nChannels=3;
      break;
    case BIAS::ImageBase::CM_RGBA:
      //COUT("DBG CM_RGBA\n");
      magickMap="RGBA";
      nChannels=4;
      break;
    case BIAS::ImageBase::CM_BGR:
      //COUT("DBG CM_BGR\n");
      magickMap="BGR";
      nChannels=3;
      break;

    default:
      BIASERR("unknown result Color Model "<<result.GetColorModel()<<" "
              <<"reading "<<FileName<<endl);
    };

    // init/allocate result color image data:
    if (!result.IsEmpty()) result.Release(true);
    result.Init((unsigned int)image.columns(), (unsigned int)image.rows(), nChannels);
    result.SetColorModel(ImageBase::CM_RGB);


    // get the pointer to our result BIAS image data:
    unsigned char* p_imageData     =  (unsigned char*)result.GetImageData();
    BIASASSERT( p_imageData != NULL);
    // write data array from read in ImageMagick++ image
    // to our own ImageData Array.
    // details: http://studio.imagemagick.org/Magick++/Image.html#write
    image.write(0,0, // upper left corner of region to extract
                result.GetWidth(), result.GetHeight(), // region size to extract
                "RGB", // map=output format in our pixel data, e.g RGBA
                outputST,
                p_imageData // pointer to our data array of type
                );
    if (readMetaData){
      BIASERR("reading of MetaData is not implemented for IMageMagick++ but could be done using BIAS::ImageAttributes class(10/2004)\n");
    }
  }
  catch( Magick::Exception &error_ ) {
    BIASERR("Reading "<<FileName<<" with Magick++ failed."<<endl
            <<"  Caught exception: "<<endl
            <<"  "<<error_.what()<<endl );
    return -1; // error
  }
  catch (...) {
    BIASERR("Reading "<<FileName<<" with Magick++ failed."<<endl);
    return -2; // error
  }
  return  BIAS_IO_SUCCESS;// OK
}


int ImageIO::
ExportMagickPP(const std::string& FileNameStr,
               ImageBase input,
               const int &quality,
               const bool &writeMetaData,
               const bool &forceBinaryPNMformat,
               const bool &losslesJpgMode,
               const bool &writeGZipped,
               const string & comment
               )
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  // binding local namespace scope
  //using namespace Magick;
  //using namespace MagickLib;

  // const to var. conversio to add .gz suffix (later);
  string FileName(FileNameStr);
  string commentTmp;
  commentTmp.append(comment);

#ifdef WIN32
  // initialize DLL loaded library (not required on Linux but once on Windows)
  Magick::InitializeMagick(NULL);
#endif

  if(input.GetChannelCount()==1){
    string ext = FileHandling::LowerCase( FileHandling::Suffix(FileName) );
    if (ext == ".jpg" || ext == ".png"){
      cout << "One channel and file suffix is" << ext << endl;
      if (input.GetStorageType() == ImageBase::ST_unsignedchar){
        BIASWARN("JPEG / PNG does not support grey scale images. Converting image to RGB.");
        Image<unsigned char> source(input);
        Image<unsigned char> dest;
        ImageConvert::ToRGB(source, dest);
        ImageBase tmp = input;
        input.Release();
        input.Init(dest.GetWidth(),dest.GetHeight(),3);
        input = dest;
        input.SetColorModel(ImageBase::CM_RGB);
      }
    }
  }
  Magick::Image image;
  //convert Image
  int ret = BIAS::ImageConvert::BIAS2ImageMagick(input, image);
  if(ret != 0) return ret;

  try {
    // for jpeg compression:
    image.quality(quality);
    // ASCII / binary data format:
    if (forceBinaryPNMformat){
        string ext = FileHandling::LowerCase( FileHandling::Suffix(FileName) );
        // useful option only for pnm images
        if ((ext==".pnm")|| (ext==".pbm")|| (ext==".pgm")|| (ext==".ppm")) {
            // to write Binary data (instead of ASCII)
            // set any compression except "none" and "unknown", e.g. RLE works
            // no matter if this compression is really used by coder...
            //image.compressType(UndefinedCompression); // makes binary data, too.
            //image.compressType(NoCompression);
            //image.compressType(BZipCompression);
            //image.compressType(FaxCompression);
            //image.compressType(Group4Compression);
            //image.compressType(JPEGCompression);
            //image.compressType(JPEG2000Compression);
            //image.compressType(LosslessJPEGCompression);
            //image.compressType(LZWCompression);
                        image.compressType(Magick::RLECompression);
            //image.compressType(ZipCompression);
        } else {
            // ASCII PNM - blows size up compared to binary writing
                        image.compressType(Magick::NoCompression);
        }
    } // textInsteadOfBinaryMode
    if (losslesJpgMode){
                image.compressType(MagickLib::LosslessJPEGCompression);
        /// quality and compession are two different parameters in jpeg
        /// but the user usually wants lossles *and* no compression on lossless flag,
        /// so force 100% quality, here:
        image.quality(100);
    }

    // non const copy: add suffix for zipped format
    // useful for ASCII text format liek ASCII pgm --> .pgm.gz
    if (writeGZipped){
      if (FileHandling::Suffix(FileName)!=".gz")
        FileName+=".gz";
    }
        #if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    COUT("DBG writing "<<input.GetWidth()<<"x"<<input.GetHeight()<<" "
                <<FileName <<"\" using ImageMagick++ "<<endl);
        #endif // BIAS_DEBUG

    if (writeMetaData) {
        /// Comment header is limited to 4096 Bytes for some formats
        /// and ASCII BIAS::MetaData representation may be too long to do so!
        string ext = FileHandling::LowerCase(FileHandling::Suffix(FileName));
        if(ext == ".png"){
            stringstream ss;
            BIASASSERT(input.GetMetaData() != NULL);
            input.GetMetaData()->WriteAscii(ss);
            commentTmp.append(ss.str());
        }
        else{
                #if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
            BIASERR("writing MetaData using ImageMagick IO is not implemented.");
                #endif
        }
    }
    // write supplied comment/description data
    if (commentTmp.size()>=4096){
      BIASWARN("comment size "<<comment.size()<<" is >= 4096 characters. This may be too long for some image formats.");
    }
    image.comment( commentTmp ); //< replaces
    // start *really* writing to disk using Magick++
    // output file type is automatically determined by magick file extension
    image.write(FileName);
  }
  catch( Magick::Exception &error_ ) {
    BIASERR("Writing "<<FileName<<" with Magick++ failed."<<endl
            <<"  Caught exception: "<<endl
            <<"  "<<error_.what()<<endl );
    return -1; // error
  }
  catch(...) {
    BIASERR("Writing "<<FileName<<" with Magick++ failed."<<endl);
    return -2; // error
  }

  return  BIAS_IO_SUCCESS;// OK
}

#endif // BIAS_HAVE_IMAGEMAGICKLIB


int ImageIO::
ImportRAWwithHeader(const std::string & filename,
                    BIAS::ImageBase & img)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  // header data size:
  unsigned int hdrSZ=0;
  // tags to find
  unsigned int Cols=0;
  unsigned int Rows=0;


  { // scope
    ifstream is;
    is.open(filename.c_str());
    //is.open(filename.c_str(), ios::binary);
    //is.open(filename.c_str(), ios_base::in |ios_base::binary );
    if (!is){
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
      BIASERR("could not open image file: "<<filename);
#endif
      is.close();
      return -1;
    }
    // OK
    string line;
    getline(is, line);
    //cout<<"DBG "<<FUNCNAME<<"line: "<<line<<endl;
    if (line.size()<3) return -2; // too small.

    // parse header:
    string ref7("RAW4096"); // 7 Bytes instead of std. 8 for backward compatibility
    string ref("RAW04096");
    if ( (0==line.compare(0, ref.size(), ref))
         || (0==line.compare(0, ref7.size(), ref7)) )
      {
        COUT("RAW04096/RAW4096 found."<<endl);
        hdrSZ=4096;
      } else {
      ref="RAW08192";
      if (0==line.compare(0, ref.size(), ref)){
        hdrSZ=8192;
      } else {
        ref="2048";
        if (0==line.compare(0, ref.size(), ref)){
          hdrSZ=2048;
        } else {
          ref="1024";
          if (0==line.compare(0, ref.size(), ref)){
            hdrSZ=1024;
          } else {
            ref="0512";
            if (0==line.compare(0, ref.size(), ref)){
              hdrSZ=0512;
            } else {
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
              BIASERR(filename<<" is no RAW4096/RAWnnnn image. aborting.");
#endif
              return -3;
            }
          }
        }
      }
    }


    // create string that can be used as char array:
    string hdr(hdrSZ,' ');
    is.seekg(ios::beg);
    // read data as a block:
    is.read(&(hdr[0]), hdrSZ);

    bool ok=true;
    //ok = ok && (0==Parse(hdr, "Cols=", Cols));
    ok = ok && (0==ParseRAWwithHeader(hdr, "RowInc=", Cols));
    ok = ok && (0==ParseRAWwithHeader(hdr, "Rows=", Rows));

    if (ok) cout<<"found dim "<<Cols<<"x"<<Rows<<endl;
    is.close();
  }

  if (!img.IsEmpty()) img.Release(true);
  // content of RAW is fixed for scorpion 1600x1200 as RAW 1 plane Bayer pattern, 8 bit.
  img.Init(Cols, Rows, 1);
  img.SetColorModel(BIAS::ImageBase::CM_Bayer_RGGB);

  
  // reopen file with C fopen intead of C++ fstream
  // USE C because of higher performance (measured 15%)
  // Linux reads only one line - thu it is not using binary mode!
  FILE * fp=NULL;
  
#ifdef WIN32
  if (fopen_s(&fp, filename.c_str(), "rt") != 0) {
    cout<<"could not open "<<filename<<" for C reading"<<endl;
    return -3;
  }
#else //WIN32
  fp = fopen(filename.c_str(), "rt");
  if (fp==NULL){
    cout<<"could not open "<<filename<<" for C reading"<<endl;
    return -3;
  }
#endif //WIN32
  //OK
  unsigned int dataSZ=Cols*Rows;
  //memset(&(img.GetImageData()[0]), 0, dataSZ);
  {
    char * p_data = new char[dataSZ];
    memset(p_data, 0, dataSZ);

    // skip header
    fread( p_data, hdrSZ, 1, fp );

    // read data:
    fread( p_data, dataSZ, 1, fp );

    img.CopyIn_NoInit(p_data);
    //tmp.CopyIn_NoInit(p_data);

    fclose(fp);
    delete p_data;
  }

  return 0; // OK
}


int ImageIO::
ParseRAWwithHeader(const std::string & buf,
                                const std::string & tag,
                                unsigned int & retVal)
{
  string::size_type posStart, posEnd;
  string valueStr;
  posStart=buf.find(tag, 0);
  if (posStart!=string::npos){
    // found tag
    posEnd = buf.find( string("\n"), posStart);
    if (posEnd!=string::npos){
      valueStr=buf.substr(posStart+tag.size(), posEnd-posStart-tag.size());
      stringstream ss;
      ss.str(valueStr);
      ss>>retVal;
      cout<<"valueStr="<<valueStr<<" : "<<retVal<<endl;
    }
  } else {
    cout<<"not found!"<<endl;
    return -1;
  }
  // OK.
  return 0;
}


#ifdef WIN32
#  pragma warning (push)
#  pragma warning (disable: 4702) // unreachable code
int ImageIO::
WriteUnbuffered(const std::string& /*FileName*/,
                const ImageBase &/*img*/)
{
  BIASERR("ImageIO::WriteUnbuffered() not implemented in Win32");
  BIASABORT;
  return -1;
}
#  pragma warning (pop)

#else // WIN32
# ifdef __APPLE__
int ImageIO::
WriteUnbuffered(const std::string& /*FileName*/,
                const ImageBase &/*img*/)
{
  BIASERR("ImageIO::WriteUnbuffered() not implemented in Win32");
  BIASABORT;
  return -1;
}
# else // __APPLE__


int ImageIO::
WriteUnbuffered(const std::string& FileName,
                const ImageBase &img_const)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif // defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)

  ImageBase img(img_const);

  if (!img.GetUID().IsValid())
    img.SetUID(UUID::GenerateUUID());

  std::ostringstream FlatImage;
  FlatImage << img;
  img.GetMetaData()->WriteBinary(FlatImage);
  FlatImage.flush();
  unsigned long int is = FlatImage.str().size();
  //   cout <<"FlatImage.size: "<<is<<endl;;
  if (MemAlignedBufferSize_ < is) {
    if (MemAlignedBuffer_ != NULL) free(MemAlignedBuffer_);
    MemAlignedBufferSize_ = 512;
    while (MemAlignedBufferSize_ < is)
      MemAlignedBufferSize_ +=512;

    // TODO: warning: dereferencing type-punned pointer will break strict-aliasing rules

    //     cout <<"New MemAlignedBuffer_ with size "<<MemAlignedBufferSize_ <<endl;
    char** bufferPointer = &MemAlignedBuffer_;
    int r = posix_memalign((void**)bufferPointer, 512,
                           MemAlignedBufferSize_);
    if (r!=0){
      BIASERR("posix_memalign failed: "<<r);
      return -1;
    }

    if (MemAlignedBuffer_ == NULL) {
      BIASERR("Can not posix_memalign()"<<MemAlignedBufferSize_<<" bytes");
      return -1;
    }
  }
  // copy flattened image into Buffer
  memcpy(MemAlignedBuffer_, FlatImage.str().c_str(), is);

  int fd = open(FileName.c_str(), O_WRONLY | O_CREAT | O_DIRECT, 0644);
  if (fd <0) {
    BIASERR("Can not open/create file ");
    perror(FileName.c_str());
    return -1;
  }
  fchmod(fd,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
  int res = write(fd,MemAlignedBuffer_, MemAlignedBufferSize_);
  if (res <0) {
    BIASERR("Can not write with O_DIRECT to file ");
    perror(FileName.c_str());
    return -1;
  }

  close(fd);

  return 0;
}
#  endif // __APPLE__
#endif // WIN32



#ifdef BIAS_HAVE_DEVIL
void ImageIO::
InitDevIL()
{
  static bool il_initialized=false;
  // once
  if (!il_initialized)
    {
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
      // Check if the shared lib's version matches the executable's version.
      if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION) {
        BIASERR("DevIL/OpenIL: "<<endl
                <<"IL versions of run-and compiletime are different. "<<endl
                <<"compile time IL_VERSION    ="<<IL_VERSION<<endl
                <<"runtime      IL_VERSION_NUM="<<ilGetInteger(IL_VERSION_NUM)<<endl
                <<"There is a risk that the headers dont match the shared library/DLL. ");
      };
#  ifdef USE_DEVIL_ILU
      if (iluGetInteger(ILU_VERSION_NUM) < ILU_VERSION) {
        BIASERR("DevIL/OpenIL: "
                <<"ILU versions of run-and compiletime are different. "
                <<" There is a risk that the headers dont match the DLL. ");
      };
#  endif // USE_DEVIL_ILU
#endif // BIAS_DEBUG && ImageIO_DEBUG_IO

      // global state initialization, required once:
      ilInit();
#ifdef USE_DEVIL_ILU
      iluInit();
#endif

      // done:
      il_initialized=true;

#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
      COUT("initialized DevIL(OpenIL) runtime version: "
           <<ilGetInteger(IL_VERSION_NUM)<<endl );
#endif
    }
}


void ImageIO::
PrintInfoDevIL(std::ostream & os)
{
  os
    <<"dim:         "<<ilGetInteger(IL_IMAGE_WIDTH)<<"x"
    <<ilGetInteger(IL_IMAGE_HEIGHT)<<" pixel"<<endl
    <<"depth=planes "<<ilGetInteger(IL_IMAGE_DEPTH)<<" plane(s) ";
  if (ilGetInteger(IL_IMAGE_DEPTH)>1)
    os<<"(tex3D)";
  os<<endl;
  os<<"size of data "<<ilGetInteger(IL_IMAGE_SIZE_OF_DATA)<<" Byte total"<<endl
    <<"BytePerPixel "<<ilGetInteger(IL_IMAGE_BPP)<<endl
    <<"Bytes/Pixel  "<<ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL)<<endl
    <<"Bits/Pixel   "<<ilGetInteger(IL_IMAGE_BITS_PER_PIXEL)<<endl
    <<"num images   "<<ilGetInteger(IL_NUM_IMAGES)<<endl
    <<"num mipmaps  "<<ilGetInteger(IL_NUM_MIPMAPS)<<endl

    <<"origin_set   "<<ilGetInteger(IL_ORIGIN_SET)<<" "
    <<"image_origin "<<ilGetInteger(IL_IMAGE_ORIGIN)<<" "
    ;
  switch (ilGetInteger(IL_IMAGE_ORIGIN)) {
  case IL_ORIGIN_SET:
    os<<"IL_ORIGIN_SET"; break;
  case IL_ORIGIN_LOWER_LEFT:
    os<<"IL_ORIGIN_LOWER_LEFT"; break;
  case IL_ORIGIN_UPPER_LEFT:
    os<<"IL_ORIGIN_UPPER_LEFT"; break;
  case IL_ORIGIN_MODE:
    os<<"IL_ORIGIN_MODE"; break;
  };
  os<<endl;

  os<<"offset       "
    <<ilGetInteger(IL_IMAGE_OFFX)<<" "<<ilGetInteger(IL_IMAGE_OFFY)<<endl
    ;
}

int ImageIO::
ImportDevIL(const std::string& FileName,
            ImageBase& result,
            const unsigned int & tex3DplaneZ )
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  if (!result.IsEmpty()) result.Release(true);

  InitDevIL();
  ILuint id(0), err(0);
  ilGenImages(1, &id);
  ilBindImage( id );

  bool ok = (IL_TRUE==ilLoadImage( (char*)(FileName.c_str()) ));

  err = ilGetError();
  if (err!=IL_NO_ERROR || !ok) {
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    stringstream ss;
    ss<<"could not load "<<FileName<<" ";
#  ifdef USE_DEVIL_ILU
    // there is no erro msg of !ok is the reason for failure and no err
    if (err!=IL_NO_ERROR)
      ss<<": "<<iluErrorString(err);
#  endif
    BIASERR(ss.str());
#endif // BIAS_DEBUG && ImageIO_DEBUG_IO
    ilDeleteImages(1, &id);
    return -1;
  }

#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  PrintInfoDevIL();
#endif

  // multiple pages/planes per image, useful for tiff etc.
  const int nDepthPlanes = int( ilGetInteger(IL_IMAGE_DEPTH) );
  if (nDepthPlanes>1){

    BIASERR("detected tex3D with "<<nDepthPlanes<<" planes. It is a volume, not a 2D texture. NOT implemented.");
    BIASBREAK;
    ilDeleteImages(1, &id);
    return -1;
  }

  // tex3D access?
  if (nDepthPlanes<(int)tex3DplaneZ ){
    BIASERR("Image has only "<<nDepthPlanes<<" z planes, but you requested tex3DplaneZ="<<tex3DplaneZ);
    BIASBREAK;
    ilDeleteImages(1, &id);
    return -1;
  }

  // determine pixel data type:
  BIAS::ImageBase::EStorageType  st = BIAS::ImageBase::ST_invalid;
  const int typeIL = (int)ilGetInteger(IL_IMAGE_TYPE);
  switch (typeIL)
    {
    case IL_BYTE:
      st = ImageBase::ST_char; break;
    case IL_UNSIGNED_BYTE:
      st = ImageBase::ST_unsignedchar; break;
    case IL_SHORT:
      st = ImageBase::ST_shortint; break;
    case IL_UNSIGNED_SHORT:
      st = ImageBase::ST_unsignedshortint; break;
    case IL_INT:
      st = ImageBase::ST_int; break;
    case IL_UNSIGNED_INT:
      st = ImageBase::ST_unsignedint; break;
    case IL_FLOAT:
      st = ImageBase::ST_float; break;
    case IL_DOUBLE:
      st = ImageBase::ST_double; break;
    default:
      BIASERR("unsupported storage type");
    }

  unsigned int channels=3;
  BIAS::ImageBase::EColorModel cm=BIAS::ImageBase::CM_invalid;
  // switch fmt to determine nr. of channels, channel order and seq.
  int formatIL = (int)ilGetInteger(IL_IMAGE_FORMAT);
  switch (formatIL)
    {
    case IL_RGB:
      channels=3;
      cm=BIAS::ImageBase::CM_RGB;
      break;
    case IL_RGBA:
      channels=4;
      cm=BIAS::ImageBase::CM_RGBA;
      break;
    case IL_BGR:
      channels=3;
      cm=BIAS::ImageBase::CM_BGR;
      break;
    case IL_BGRA:
      channels=4;
      cm=BIAS::ImageBase::CM_BGRA;
      break;
    case IL_LUMINANCE:
      channels=1;
      cm=BIAS::ImageBase::CM_Grey;
      break;
    case IL_LUMINANCE_ALPHA:
      channels=2;
      cm=BIAS::ImageBase::CM_GreyA;
      break;
    default:
      BIASERR("unsupported format");
    }

  // always interleaved
  const bool interleaved = true;
  // dim in pixel
  const unsigned int w = ilGetInteger(IL_IMAGE_WIDTH);
  const unsigned int h = ilGetInteger(IL_IMAGE_HEIGHT);

  // allocate new image
  result.Init(
              w,h,
              channels,
              st,
              interleaved );
  result.SetColorModel(cm);

#ifdef BIAS_DEBUG
  const int bytePerPixIL = int(ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL));
  const int bitPerPixIL  = int(ilGetInteger(IL_IMAGE_BITS_PER_PIXEL ));
  BIASASSERT(int(result.GetDepth()*result.GetChannelCount())    == bytePerPixIL);
  BIASASSERT(int(result.GetBitDepth()*result.GetChannelCount()) >= bitPerPixIL );

  {
    const int ilSZ = ilGetInteger(IL_IMAGE_SIZE_OF_DATA);
    BIASASSERT(int(result.GetPixelCount()*result.GetDepth()*result.GetChannelCount()) == ilSZ);
  }
#endif

  if (ilGetData() == NULL){
    BIASERR("ilGetData NULL");
    ilDeleteImages(1, &id);
    return -1;
  };

  // copy the data area
  //result.CopyIn_NoInit( ilGetData() );
  //result.CopyIn_NoInit( ilGetData() );
  ilCopyPixels(0,0,0, /* x y z offset */
               w,h,
               tex3DplaneZ, /* depth planes, 1 for tex2D */
               formatIL,    /* format, e.g. IL_RGBA */
               typeIL,      /* type, e.g. UL_UNSIGNED_BYTE */
               result.GetImageData() /* dest ptr */
               );
  result.UpdateImageDataArrayFromImageData_();

  // free temporary devIL image
  ilDeleteImages(1, &id);

  return BIAS_IO_SUCCESS; // OK
}


int ImageIO::
ExportDevIL(const std::string& FileName,
            const ImageBase& img,
            const bool &fileOverwrite,
            const bool &allowPadding )
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  InitDevIL();

  ILuint id=0;
  ILuint err=0;
  ilGenImages(1, &id);
  ilBindImage( id );

  // fill attributes and data
  unsigned int w=img.GetWidth();
  unsigned int h=img.GetHeight();
  unsigned int depth=img.GetDepth();
  ILenum ilFormat=IL_RGB; //< defaut
  ILenum ilType  =IL_BYTE; //< default

  // overwrite file if exists?
  if (fileOverwrite) {
    ilEnable(IL_FILE_OVERWRITE);
  } else {
    ilDisable(IL_FILE_OVERWRITE);
  }


  // native storage data type:
  switch (img.GetStorageType())
    {
    case ImageBase::ST_char:
      ilType=IL_BYTE;  break;
    case ImageBase::ST_unsignedchar:
      ilType=IL_UNSIGNED_BYTE;  break;
    case ImageBase::ST_shortint:
      ilType=IL_SHORT;  break;
    case ImageBase::ST_unsignedshortint:
      ilType=IL_UNSIGNED_SHORT;  break;
    case ImageBase::ST_int:
      ilType=IL_INT;  break;
    case ImageBase::ST_unsignedint:
      ilType=IL_UNSIGNED_INT;  break;
    case ImageBase::ST_float:
      ilType=IL_FLOAT;  break;
    case ImageBase::ST_double:
      ilType=IL_DOUBLE;  break;
    default:
      BIASERR("unsupported storage type");
    }

  //#ifdef BIAS_DEBUG
  //  const unsigned int channels=img.GetChannelCount();
  //#endif

  // format --> native nr+seq of channels and color model
  switch (img.GetColorModel())
    {
    case BIAS::ImageBase::CM_RGB:
      ilFormat=IL_RGB;
      BIASASSERT(img.GetChannelCount()==3);
      break;
    case BIAS::ImageBase::CM_RGBA:
      ilFormat=IL_RGBA;
      BIASASSERT(img.GetChannelCount()==4);
      break;
    case BIAS::ImageBase::CM_BGR:
      ilFormat=IL_BGR;
      BIASASSERT(img.GetChannelCount()==3);
      break;
    case BIAS::ImageBase::CM_BGRA:
      ilFormat=IL_BGRA;
      BIASASSERT(img.GetChannelCount()==4);
      break;
    case BIAS::ImageBase::CM_Grey:
      ilFormat=IL_LUMINANCE;
      BIASASSERT(img.GetChannelCount()==1);
      break;
    case BIAS::ImageBase::CM_GreyA:
      ilFormat=IL_LUMINANCE_ALPHA;
      BIASASSERT(img.GetChannelCount()==2);
      break;
    default:
      BIASERR("unsupported color model/channelcount/ DevIL type");
    }

  // Byte per Pixel, e.g. 3 for "unsigned char RGB" image
  unsigned int BytePerPixel = img.GetDepth()*img.GetChannelCount();

  // create temporary DevIL image
  // setting attributes and copy data
  if (!ilTexImage(
                  w,h,
                  depth,
                  ILubyte (BytePerPixel),
                  ilFormat,
                  ilType,
                  //(ILvoid*)(img.GetImageData())
                  NULL
                  ))
    {
      BIASERR("could not set DevIL attributes for saving "<<FileName);
      ilDeleteImages(1, &id);
      return -1;
    }

  // BIAS image coordinate system has origin in upper left corner
  // (in contrast to OpenGLs lower left)
  ilRegisterOrigin(IL_ORIGIN_UPPER_LEFT);

  BIASASSERT(img.GetImageData()!=NULL);
  // memcopy the image data:
  ilSetData((ILvoid*)(img.GetImageData()) );

  // check status
  err = ilGetError();
  if (err!=IL_NO_ERROR) {
    stringstream ss;
    ss<<"could not set DevIL for saving "<<FileName<<" ";
#ifdef USE_DEVIL_ILU
    ss<<": "<<iluErrorString(err);
#endif
    BIASERR(ss.str());
    ilDeleteImages(1, &id);
    return -1;
  }

  BIASASSERT(int(img.GetDepth())==int(ilGetInteger(IL_IMAGE_DEPTH)) );
#ifdef BIAS_DEBUG
  {
    const int ilSZ = ilGetInteger(IL_IMAGE_SIZE_OF_DATA);
    BIASASSERT(
               int(img.GetPixelCount()*img.GetDepth()*img.GetChannelCount())==ilSZ
               );
  }
#endif

  err = ilGetError();
  if (err!=IL_NO_ERROR) {
    stringstream ss;
    ss<<"could not save to file "<<FileName<<" ";
#ifdef USE_DEVIL_ILU
    ss<<": "<<iluErrorString(err);
#endif
    PrintInfoDevIL();
    BIASERR(ss.str());
    ilDeleteImages(1, &id);
    return -2;
  }

  // write to disk:
  bool ok = (IL_TRUE==ilSaveImage( (char*)(FileName.c_str()) ));

  // check status again:
  err = ilGetError();
  if (err!=IL_NO_ERROR || !ok)
    {
      stringstream ss;
      ss<<"could not save to file "<<FileName<<" ";
#ifdef USE_DEVIL_ILU
      ss<<": "<<iluErrorString(err);
#endif
      if (err==IL_BAD_DIMENSIONS && allowPadding) {
        // try if padding helps:
        // fallback tmp padded image
        BIAS::ImageBase tmpIMG(img);
        tmpIMG.PadToPowerOfTwo();
        // do not allow padding again or we will get an endless loop!
        int resultPadded=ExportDevIL(
                                     FileName,
                                     tmpIMG,
                                     fileOverwrite,
                                     false /*allowPading?*/ );
        if (resultPadded==0)
          {
            // everything is fine,  give msg that we paded.
            ss<<endl<<"Some formats (e.g. DDS) require power of two size (and depth) "<<endl
              <<"Padding from dim "<<w<<"x"<<h<<" "
              <<"(depth="<<depth<<" ChannelCount="<<tmpIMG.GetChannelCount()<<") "
              <<"to "<<tmpIMG.GetWidth()<<"x"<<tmpIMG.GetHeight()<<" "
              <<"(depth="<<tmpIMG.GetDepth()<<" channels="<<tmpIMG.GetChannelCount()<<") "<<endl
              <<"was required to save "<<FileName;
            BIASWARN(ss.str());
          } else {
          // padding did not help
          BIASERR(ss.str());
          ilDeleteImages(1, &id);
          return -3;
        }
      } else {
        // error we could do nothing about
        BIASERR(ss.str());
        ilDeleteImages(1, &id);
        return -4;
      }
    }

  // OK:
  // free temporary devIL image
  ilDeleteImages(1, &id);

  return BIAS_IO_SUCCESS;
}
#endif  // BIAS_HAVE_DEVIL



std::string ImageIO::
GetExtension(const BIAS::ImageIO::TFileFormat & fmt)
{
  string s;
  switch (fmt)
    {
    case FF_mip:
      s="mip"; break;
    case FF_ppm:
      s="ppm"; break;
    case FF_pgm:
      s="pgm"; break;
    case FF_pbm:
      s="pbm"; break;
    case FF_jpg:
      s="jpg"; break;
    case FF_tif:
      s="tif"; break;
    case FF_png:
      s="png"; break;
    case FF_viff:
      s="vif"; break;
    case FF_exr:
      s="exr"; break;
    case FF_dds:
      s="dds"; break;
    case FF_raw4096:
      s="raw"; break;
    case FF_bmp:
        s="bmp"; break;
    case FF_Real32:
        s="real32"; break;
    case FF_matrix:
        s="matrix"; break;
    case FF_auto:
    case FF_unknown:
    default:
      BIASERR("Unknown FileFormat "<<fmt<<" Please add switch case");
    }
  return s;
}



BIAS::ImageIO::TFileFormat ImageIO::
GetFileFormat(const std::string &str)
{
  // suffix = "dot"+extension
  string ext=FileHandling::LowerCase( FileHandling::Extension(str) );
  // compare ext to all FF_* fixed formats:
  // if no extension specified use mip automatically as default - Fernandez 04/09
  if (ext=="mip" || ext == "") {
    return FF_mip;
  } else if (
             (ext=="ppm") ||
             (ext=="pnm") /* pNm can be pbm, pgm, ppm. assume color for pnm. */
             )
    {
      return FF_ppm;
    } else if (ext=="pgm") {
    return FF_pgm;
  } else if (ext=="pbm") {
    return FF_pbm;
  } else if (
             (ext=="jpg") ||
             (ext=="jpe") ||
             (ext=="jpeg")
             )
    {
      return FF_jpg;
    } else if (
               (ext=="tif") ||
               (ext=="tiff")
               )
    {
      return FF_tif;
    } else if (ext=="png") {
    return FF_png;
  } else if (
             (ext=="vif") ||
             (ext=="vff") ||
             (ext=="viff"))
    {
      return FF_viff;
    } else if (ext=="exr") {
    return FF_exr;
  } else if (
             (ext=="dds")  ||
             (ext=="dxt")  ||
             (ext=="dxt1") ||
             (ext=="dxt3") ||
             (ext=="dxt5") ||
             (ext=="dxtc") ||
             (ext=="s3tc")
             )
    {
      // S3's S3TC format and DXTC are essentially the same
      return FF_dds;
    } else if (
               (ext=="raw") ||
               (ext=="raw4096") ||
               (ext=="scorpion")
               )
    {
      return FF_raw4096;
    } else if ((ext=="real32") || (ext=="f32")){
    // Mathematica Real32 raw
    return FF_Real32;
  } else if (ext=="bmp") {
    return FF_bmp;
    }else if (ext=="matrix") {
        //text file format
    return FF_matrix;
  }
  else {
    // unknown ext.
    // give the external image writer libs a try,
    // they may support a wider range of extensions.
    // Thus use "FF_auto" on returned "FF_unknown"
    return FF_unknown;
  }
}


//#ifdef BIAS_HAVE_RADIANCE
int BIAS::ImageIO::
ImportRADIANCE(const std::string& FileName, ImageBase& result)
{
  ifstream is;
  is.open(FileName.c_str(), ios::binary);
  if (!is){
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    BIASERR("Could not open file "<<FileName);
#endif
    return -1;
  }
  //is.seekg(0,ios::beg);
  string buf;
  unsigned int line=0;
  getline(is, buf); line++;
  //cout<<line<<". = "<<buf<<endl;

  const string signatureRAD("#?RADIANCE");
  if (buf!= signatureRAD )
    {
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
      BIASERR("signatureRAD "<<signatureRAD<<" not found in file "<<FileName);
#endif
      return -2;
    };
  // OK, is a RADIANCE file.

  bool flipY=false, flipX=false;
  unsigned int width=0, height=0;
  //float exposure=1.0;

  // parse for FORMAT
  while (is){
    getline(is, buf); line++;
    //cout<<line<<". = "<<buf<<endl;
    // skip comments:
    if (0==buf.compare(0,1,"#")) {
      //cout<<"found comment: "<<buf<<endl;
      continue;
    }
    if (0==buf.compare(0,6,"FORMAT")) {
      // check format:
      if (0==buf.compare("FORMAT=32-bit_rle_rgbe")){
        break; // OK
      } else {
        BIASERR("Only 32-bit_rle_rgbe FORMAT supported but "<<buf<<" found. Failed to load.");
        return -5;
      }
    };
  }

  // parse for -Y or +Y
  while (is){
    getline(is, buf); line++;
    //cout<<line<<". = "<<buf<<endl;
    // skip comments:
    if (0==buf.compare(0,1,"#")) {
      //cout<<"found comment: "<<buf<<endl;
      continue;
    }
    if (0==buf.compare(0,2,"-Y")
        || 0==buf.compare(0,2,"-Y"))
      {
        // parse x and y value:
        stringstream ss(buf);
        string dummy;
        ss>>dummy; // Y
        if (dummy=="+Y"){
          flipY=true;
        } else if (dummy=="-Y") {
          // OK, no flip
        } else {
          BIASERR("expected +Y or -Y but failed.");
          return -8;
        }
        // read Y value
        ss>>height;

        ss>>dummy;// X
        if (dummy=="+X"){
          // OK, no flip
        } else if (dummy=="-X") {
          flipX=true;
        } else {
          BIASERR("expected +X or -X but failed.");
          return -9;
        }
        // read X value
        ss>>width;
        break;
      }
  };
  cout<<FUNCNAME<<" found "<<width<<"x"<<height<<" RADIANCE rle RGBE image. "<<FileName<<endl;
  // get RGBE data:
  if (!result.IsEmpty()) result.Release(true);
  result.Init(width, height, 4, BIAS::ImageBase::ST_unsignedchar, true );

  // get data
  char col[4]={0};
  unsigned int y=0;
  //unsigned int x=0;
  //int pos=0;
  //int start=0;
  //int step=1;
  for (y=0; y<height; y++) {
    //start = bFlippedY ? (height-y-1)*width : y*width;
    //step = bFlippedX ? -1 : 1;

    // read 4 Bytes of line:
    is.read(col,4);
    // is the image /line RLE compressed?
    if ( (col[0]==0x2)
         && (col[1]==0x2)
         && (col[2]==0x0) )
      {
        BIASERR("unsupported new RADIANCE compression detected in line y="<<y);
        // clear the line:
        memset( result.GetImageDataArray()[y], 0, 4*width);

      } else if ( (col[0]==0x1)
                  && (col[1]==0x1)
                  && (col[2]==0x1) )
      {
        BIASERR("unsupported old RADIANCE run scheme in line y="<<y);
        memset( result.GetImageDataArray()[y], 0, 4*width);

      } else {

      BIASERR("sorry, RADAINCE not completely implemented TODO: RLE (un-)compression is missing.");
      return -99;
      /// \todo: decode the runlength encode line, map the RGBE to float or do it in ColorConverion?

      // for now do the following two lines to avoid gcc warnings:
      flipY = !flipY;
      flipX = !flipX;
      /*
      // OK, assume line contains only raw data
      //start = flipY ? (height-y-1)*width : y*width;
      //step  = flipX ? -1 : 1;
      // Do the run
      int nPixel = ((int) col[3])&0xFF;
      unsigned char r = pBuffer[(pos-step)*4];
      unsigned char g = pBuffer[(pos-step)*4+1];
      unsigned char b = pBuffer[(pos-step)*4+2];
      unsigned char e = pBuffer[(pos-step)*4+3];

      for( int i=0; i<num; i++ ) {
      pBuffer[pos*4] = r;
      pBuffer[pos*4+1] = g;
      pBuffer[pos*4+2] = b;
      pBuffer[pos*4+3] = e;
      pos += step;
      }

      x += num-1;
      */
    }
  }
  return 0; // OK
}
//#endif // BIAS_HAVE_RADIANCE



int BIAS::ImageIO::
ImportReal32(const std::string& FileName, ImageBase& result)
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  ifstream is;
  is.open(FileName.c_str(), ios::binary);
  if (!is){
    BIASERR("Could not open file "<<FileName);
    is.close();
    return -1;
  }

  // header: 4 float
  // format, width, height, nchannels
  vector<float> header(4, 0);
  //unsigned int version=0;
  if (is)
    is.read( (char*)(&(header[0])), header.size()*sizeof(float) );

  if (!is)
    return -101;

  // supported format? simple check for now.
  const float fmt=header[0];
  if ((1.0f <= fmt) && (fmt<=1.01f)) {
    //version=1;
  } else {
    return -1; // unsupported
  }
  unsigned int width     = (unsigned int)( header[1] );
  unsigned int height    = (unsigned int)( header[2] );
  unsigned int nchannels = (unsigned int)( header[3] );

  // only small GPU suitable images are written, currently:
  // check useful header values:
  if (!(0<width))
    return -2;
  if (!(width<=4096))
    return -3;
  if (!(0<height))
    return -4;
  if (!(height<4096))
    return -5;
  if (!(0<nchannels))
    return -6;
  if (!(nchannels<=4))
    return -7;

   // (re-)allocate
  if (!result.IsEmpty())  result.Release(true);
  result.Init(width, height, nchannels, ImageBase::ST_float, true);

  // read the raw data:
  BIASASSERT(is);
  is.read( (char*)(result.GetImageData()),
           sizeof(float)*width*height*nchannels );

  is.close();
  return 0;
}



#ifdef WIN32
  // implement WINAPI specific calls for BMP loading via disk or memory

int BIAS::ImageIO::
Import_BITMAP_winapi(const std::string& FileName,
                     ImageBase& result,
                     const bool flipY )
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif

  // the WINAPI interface
  HBITMAP hbm=NULL;

  // convert from stl string to WINAPI string
  // TODO: what about UNICODE strings: use LPTSTR ?
  LPCSTR szFileName = FileName.c_str();

  // load the image from disk into a DIBSection
  hbm = (HBITMAP)
    LoadImage( NULL, szFileName, IMAGE_BITMAP, 0, 0,
               LR_LOADFROMFILE | LR_CREATEDIBSECTION | LR_DEFAULTSIZE );

  // check success
  if( hbm == NULL ){
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    BIASERR("could not load "<<FileName );
#endif
    return -1; // error, could not load
  }

  // we have a valid HBITMAP, now.
  // create object and copy  in, now.
  return BIAS::ImageIO::Import_HBITMAP_winapi(hbm,
                                              result,
                                              flipY );
}


int BIAS::ImageIO::
Import_HBITMAP_winapi(const HBITMAP & hbm,
                      ImageBase& result,
                      const bool flipY )
{
  // create object from handle
  BITMAP bm;
  const int nBytesHeader =
    GetObject( hbm, sizeof(BITMAP), &bm );
  if (nBytesHeader==0) {
    BIASERR("could not GetObject");
    return -1;
  }
  //cout<<"created object with "<<nBytes<<" Bytes."<<endl; // typically 24

  // we have a valid BITMAP, now,
  // load pixel data
  return BIAS::ImageIO::Import_BITMAP_winapi(bm,
                                             result,
                                             flipY );
}


int BIAS::ImageIO::
Import_BITMAP_winapi(const BITMAP & bm,
                     ImageBase& result,
                     const bool flipY )
{
  // If  DIBSection is 256 color or less --> color table
  if( ( bm.bmBitsPixel * bm.bmPlanes ) <= 8 ){
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    BIASERR("Could not load winapi BITMAP because it contains a color table (not implemented)" );
#endif
    return -2;
  }

  // tested only with 3 channel(BGR) interleaved images with one plane
  if (bm.bmPlanes != 1){
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
    BIASERR("Could not load winapi BITMAP because it contains more than one plane." );
#endif
    return -3;
  }

  //
  // copy pixel data into BIAS layout
  // assume 3 channel uc (3*8=24bit) interleaved DIB for now.
  //
  {
    BIAS::Image<unsigned char> img(bm.bmWidth, bm.bmHeight, 3 );
    img.SetColorModel(BIAS::ImageBase::CM_BGR); // Windows DIB = BGR

    const int nBytes = bm.bmWidthBytes*bm.bmHeight;
    memcpy(img.GetImageData(), (unsigned char*)bm.bmBits, nBytes );
    if (flipY){
      // Windows BMP has down-up vertical order like OpenGL
      img.Flip();
    }

    // Image<uc> --> ImageBase
    result = img;
  }

  return EXIT_SUCCESS;
}
#endif // WIN32





#ifdef BIAS_HAVE_TIFF
// see http://www.ibm.com/developerworks/linux/library/l-libtiff/
int BIAS::ImageIO::
ExportTIFFLIB(const std::string& FileName,
              const ImageBase& img,
              const unsigned int rowsPerStripArg,
              const unsigned int compressionAlgo,
              const string & comment )
{
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  CALLINFO;
#endif
  try {

    TIFF* tif = TIFFOpen(FileName.c_str(), "w");
    if (tif==NULL){
#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
      BIASERR("Could not open image for TIFFLIB for writing:" << FileName);
#endif
      return -1;
    }
    BIASASSERT(tif!=NULL);
    // work:

    TIFFSetField(tif, TIFFTAG_IMAGEWIDTH,      img.GetWidth() );
    TIFFSetField(tif, TIFFTAG_IMAGELENGTH,     img.GetHeight() );
    TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, img.GetChannelCount() );
    const unsigned short bitspersample =
      8* (unsigned short)img.GetDepth(); // img.GetBiTDepth()
    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitspersample ); // more than enough
    TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT); // origin 0,0
    // assume planar tiff cfg., needs one channel or interleaved pixel data
    BIASASSERT((img.GetChannelCount()==1) || (img.IsInterleaved()) );
    TIFFSetField(tif, TIFFTAG_PLANARCONFIG,    PLANARCONFIG_CONTIG);


    //TIFFSetField(tif, TIFFTAG_COMPRESSION,     COMPRESSION_NONE); //(300 msec)
    //TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW); // works, lossless Lempel Ziff Welch  (650msec)
    //TIFFSetField(tif, TIFFTAG_COMPRESSION,     COMPRESSION_DEFLATE); // works,lossless compression known as Zip-in-TIFF (1750 msec)
    TIFFSetField(tif, TIFFTAG_COMPRESSION, compressionAlgo); // TODO: check if this is a valid compressoinalgorithm

    // size of strips = nr. of lines taht form a strip
    unsigned int rowsPerStrip  = rowsPerStripArg;
    if (rowsPerStrip <= 0)
      rowsPerStrip = img.GetHeight();
    if (rowsPerStrip>img.GetHeight()) {
      BIASERR("rowsPerStrip="<<rowsPerStrip<<" exceed limit. resetting to img height="<<img.GetHeight());
      rowsPerStrip=img.GetHeight();
    }
    /// \todo TODO: do we need to check that rowsPerStrip is modulo image height?
    BIASASSERT(rowsPerStrip >= 0 );
    BIASASSERT(rowsPerStrip <= img.GetHeight() );
    TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsPerStrip);

    //TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
    //TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
    //TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE);
    switch (img.GetChannelCount()){
    case 1:
      TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK); break;
      //case 2:
    case 3:
      TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB); break;
      //case 4:
    default:
      {
        BIASERR("unhandled nr. of channels.");
        return -1;
      }
    }

    //// optional tags
    TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "written Jan Woetzel");
    const string cvsVersion = "CVS $Revision: 2.170 $";
    stringstream swSS;
    swSS <<"BIAS::ImageIO "
         <<"BIAS-"<<BIAS_VERSION_MAJOR<<"."<<BIAS_VERSION_MINOR<<"."<<BIAS_VERSION_PATCH
         <<" "<<cvsVersion<<" (Jan Woetzel)";
    TIFFSetField(tif, TIFFTAG_SOFTWARE, swSS.str().c_str() );

    //TIFFSetField(tif, TIFFTAG_XRESOLUTION, 150.0);
    //TIFFSetField(tif, TIFFTAG_YRESOLUTION, 150.0);
    //TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH); // RESUNIT_CENTIMETER

    // write TIFF in scanlines
    int res=0;
    //if (rowsPerStrip==1)
    //{
    //  // use scanline based API
    //  0000000000000000 these are scanlines
    //  1111111111111111
    //  2222222222222222
    //  for (unsigned int y=0; y<img.GetHeight(); y+=rowsPerStrip ){
    //    void* pd = img.GetImageDataArray()[y];
    //    // 1is returned on success
    //    res = TIFFWriteScanline(tif, pd, y, 0);
    //    BIASASSERT(res==1);
    //  }
    //}
    //else
    {
      // use strip based API, possibly encoded
      // 0000000000  these are strips
      // 0000000000
      // 1111111111
      // 1111111111
      // TODO must rowsPerStrip be module height?
      const unsigned int nBytes = rowsPerStrip * img.GetWidth()*img.GetChannelCount()*img.GetDepth() ;
      int strip =0;
      for (unsigned int y=0; y<img.GetHeight(); y+=rowsPerStrip){
        // the number of written Bytes is returned
        res = TIFFWriteEncodedStrip(tif, strip, img.GetImageDataArray()[y], nBytes );
        BIASASSERT((int)res==(int)nBytes);
        strip++;
      }
    }

    TIFFClose(tif);
    return EXIT_SUCCESS;

  } catch (...){
    BIASERR("catched tifflib exception");
    return -1;
  }
}


int BIAS::ImageIO::
ImportTIFFLIB(const std::string& FileName, ImageBase& img )
{
  //  /*
  //#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  //  CALLINFO;
  //#endif
  //  try {
  //
  //    TIFF* tif = TIFFOpen(FileName.c_str(), "r");
  //    if (tif==NULL){
  //#if defined(BIAS_DEBUG) && defined(ImageIO_DEBUG_IO)
  //      BIASERR("Could not open image for TIFFLIB for reading:" << FileName);
  //#endif
  //      return -1;
  //    }
  //    BIASASSERT(tif!=NULL);
  //
  //    // work:
  //
  //    int width=0, height=0, channelcount=0, bitpersample=0;
  //
  //    // Check that it is of a type that we support
  //
  //
  //
  //      if((== 0) || (bps != 1)){
  //        fprintf(stderr, "Either undefined or unsupported number of bits per sample\n");
  //        exit(42);
  //      }
  //
  //      if((TIFFGetField(image, TIFFTAG_SAMPLESPERPIXEL, &spp) == 0) || (spp != 1)){
  //        fprintf(stderr, "Either undefined or unsupported number of samples per pixel\n");
  //        exit(42);
  //      }
  //
  //    TIFFGetField(image, TIFFTAG_BITSPERSAMPLE, &bitpersample) ;
  //
  //
  //    TIFFGetField(tif, TIFFTAG_IMAGEDESCRIPTION, "written by BIAS::ImageIO (Jan Woetzel)");
  //    TIFFGetField(tif, TIFFTAG_IMAGEWIDTH,      img.GetWidth() );
  //    TIFFGetField(tif, TIFFTAG_IMAGELENGTH,     img.GetHeight() );
  //    TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, img.GetChannelCount() );
  //    TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE,   8*img.GetDepth() ); // more than enough
  //    //TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE,   img.GetBitDepth() ); // exactly enough
  //    TIFFGetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT); // origin 0,0
  //    // assume planar tiff cfg., needs one channel or interleaved pixel data
  //    BIASASSERT((img.GetChannelCount()==1) || (img.IsInterleaved()) );
  //    TIFFGetField(tif, TIFFTAG_PLANARCONFIG,    PLANARCONFIG_CONTIG);
  //
  //
  //    // read TIFF in scanlines
  //    int res=0;
  //    //if (rowsPerStrip==1)
  //    //{
  //    //  // use scanline based API
  //    //  0000000000000000 these are scanlines
  //    //  1111111111111111
  //    //  2222222222222222
  //    //  for (unsigned int y=0; y<img.GetHeight(); y+=rowsPerStrip ){
  //    //    void* pd = img.GetImageDataArray()[y];
  //    //    // 1is returned on success
  //    //    res = TIFFReadScanline(tif, pd, y, 0);
  //    //    BIASASSERT(res==1);
  //    //  }
  //    //}
  //    //else
  //    {
  //      // use strip based API, possibly encoded
  //      // 0000000000  these are strips
  //      // 0000000000
  //      // 1111111111
  //      // 1111111111
  //      // TODO must rowsPerStrip be module height?
  //      const unsigned int nBytes = rowsPerStrip * img.GetWidth()*img.GetChannelCount()*img.GetDepth() ;
  //      int strip =0;
  //      for (unsigned int y=0; y<img.GetHeight(); y+=rowsPerStrip){
  //        // the number of written Bytes is returned
  //        res = TIFFReadEncodedStrip(tif, strip, img.GetImageDataArray()[y], nBytes );
  //        BIASASSERT((int)res==(int)nBytes);
  //        strip++;
  //      }
  //    }
  //
  //    TIFFClose(tif);
  //    return EXIT_SUCCESS;
  //
  //  } catch (...){
  //    BIASERR("catched tifflib exception");
  //    return -1;
  //  }
  //  */
  return -1;
}
#endif // BIAS_HAVE_TIFF