ImageAttributes.cpp

#include "ImageAttributes.hh"
#include <Base/Common/W32Compat.hh>
#include <math.h>
#include <Base/Debug/DebugSimple.hh>
#include <Base/Debug/Error.hh>
#include <Base/Common/FileHandling.hh>

#include <string>
#include <exception>
#include <iostream>
#include <iterator>
#include <climits>
#include <typeinfo>
#ifdef WIN32
#undef max
#endif

using namespace std;
using namespace BIAS;

#define METER_PER_INCH  0.0254

/** @class TagInfo
 *  @brief compatibility class for ImageMagick/magick/attribute.c:
    @author Jan Woetzel
    @date 10/2004 */
class TagInfo {
public:
  unsigned short tag;
  char *description;
};

/** @brief compatibility class for ImageMagick/magick/attribute.c
    contains all known EXIF tags
    @author jan Woetzel */
static TagInfo tag_table[] =   {
  {  0x100, (char *) "ImageWidth"},
  {  0x101, (char *) "ImageLength"},
  {  0x102, (char *) "BitsPerSample"},
  {  0x103, (char *) "Compression"},
  {  0x106, (char *) "PhotometricInterpretation"},
  {  0x10a, (char *) "FillOrder"},
  {  0x10d, (char *) "DocumentName"},
  {  0x10e, (char *) "ImageDescription"},
  {  0x10f, (char *) "Make"},
  {  0x110, (char *) "Model"},
  {  0x111, (char *) "StripOffsets"},
  {  0x112, (char *) "Orientation"},
  {  0x115, (char *) "SamplesPerPixel"},
  {  0x116, (char *) "RowsPerStrip"},
  {  0x117, (char *) "StripByteCounts"},
  {  0x11a, (char *) "XResolution"},
  {  0x11b, (char *) "YResolution"},
  {  0x11c, (char *) "PlanarConfiguration"},
  {  0x128, (char *) "ResolutionUnit"},
  {  0x12d, (char *) "TransferFunction"},
  {  0x131, (char *) "Software"},
  {  0x132, (char *) "DateTime"},
  {  0x13b, (char *) "Artist"},
  {  0x13e, (char *) "WhitePoint"},
  {  0x13f, (char *) "PrimaryChromaticities"},
  {  0x156, (char *) "TransferRange"},
  {  0x200, (char *) "JPEGProc"},
  {  0x201, (char *) "JPEGInterchangeFormat"},
  {  0x202, (char *) "JPEGInterchangeFormatLength"},
  {  0x211, (char *) "YCbCrCoefficients"},
  {  0x212, (char *) "YCbCrSubSampling"},
  {  0x213, (char *) "YCbCrPositioning"},
  {  0x214, (char *) "ReferenceBlackWhite"},
  {  0x1000, (char *) "RelatedImageFileFormat"},
  {  0x1001, (char *) "RelatedImageLength"},
  {  0x1002, (char *) "RelatedImageWidth"},
  {  0x828d, (char *) "CFARepeatPatternDim"},
  {  0x828e, (char *) "CFAPattern"},
  {  0x828f, (char *) "BatteryLevel"},
  {  0x8298, (char *) "Copyright"},
  {  0x829a, (char *) "ExposureTime"},
  {  0x829d, (char *) "FNumber"},
  {  0x83Bb, (char *) "IPTC/NAA"},
  {  0x8769, (char *) "ExifOffset"},
  {  0x8773, (char *) "InterColorProfile"},
  {  0x8822, (char *) "ExposureProgram"},
  {  0x8824, (char *) "SpectralSensitivity"},
  {  0x8825, (char *) "GPSInfo"},
  {  0x8827, (char *) "ISOSpeedRatings"},
  {  0x8828, (char *) "OECF"},
  {  0x8829, (char *) "Interlace"},
  {  0x882a, (char *) "TimeZoneOffset"},
  {  0x882b, (char *) "SelfTimerMode"},
  {  0x9000, (char *) "ExifVersion"},
  {  0x9003, (char *) "DateTimeOriginal"},
  {  0x9004, (char *) "DateTimeDigitized"},
  {  0x9101, (char *) "ComponentsConfiguration"},
  {  0x9102, (char *) "CompressedBitsPerPixel"},
  {  0x9201, (char *) "ShutterSpeedValue"},
  {  0x9202, (char *) "ApertureValue"},
  {  0x9203, (char *) "BrightnessValue"},
  {  0x9204, (char *) "ExposureBiasValue"},
  {  0x9205, (char *) "MaxApertureValue"},
  {  0x9206, (char *) "SubjectDistance"},
  {  0x9207, (char *) "MeteringMode"},
  {  0x9208, (char *) "LightSrc"},
  {  0x9209, (char *) "Flash"},
  {  0x920a, (char *) "FocalLength"},
  {  0x920b, (char *) "FlashEnergy"},
  {  0x920c, (char *) "SpatialFrequencyResponse"},
  {  0x920d, (char *) "Noise"},
  {  0x9211, (char *) "ImageNumber"},
  {  0x9212, (char *) "SecurityClassification"},
  {  0x9213, (char *) "ImageHistory"},
  {  0x9214, (char *) "SubjectLocation"},
  {  0x9215, (char *) "ExposureIndex"},
  {  0x9216, (char *) "TIFF/EPStandardID"},
  {  0x927c, (char *) "MakerNote"},
  {  0x9286, (char *) "UserComment"},
  {  0x9290, (char *) "SubSecTime"},
  {  0x9291, (char *) "SubSecTimeOriginal"},
  {  0x9292, (char *) "SubSecTimeDigitized"},
  {  0xA000, (char *) "FlashPixVersion"},
  {  0xA001, (char *) "ColorSpace"},
  {  0xA002, (char *) "ExifImageWidth"},
  {  0xA003, (char *) "ExifImageLength"},
  {  0xA005, (char *) "InteroperabilityOffset"},
  {  0xA20b, (char *) "FlashEnergy"},
  {  0xA20c, (char *) "SpatialFrequencyResponse"},
  {  0xA20e, (char *) "FocalPlaneXResolution"},
  {  0xA20f, (char *) "FocalPlaneYResolution"},
  {  0xA210, (char *) "FocalPlaneResolutionUnit"},
  {  0xA214, (char *) "SubjectLocation"},
  {  0xA215, (char *) "ExposureIndex"},
  {  0xA217, (char *) "SensingMethod"},
  {  0xA300, (char *) "FileSource"},
  {  0xA301, (char *) "SceneType"},
  {  0xA302, (char *) "CFAPattern"},
  {  0x0000, (char *) NULL}
};

/** weblinks:
http://www.awaresystems.be/imaging/tiff/tifftags/privateifd/exif/focalplaneresolutionunit.html

http://www.stefanheymann.de/homegallery/exif-felder.htm

http://www.exif.org/specifications.html

*/

// JW
void ImageAttributes::InitExifTags(){
  // get the number of tags from variable size array:

#ifndef WIN32
    const unsigned int nTags=sizeof(tag_table) / sizeof( __typeof__( *tag_table ));
#else
  /// (JW) no typeof in MS Visual Studio C++ 7.1 compiler
  const unsigned int nTags = 99; /// \todo loop until 0x0 end symbol
#endif

  //COUT("tag_table contains "<<nTags<<" tags.");
  for (unsigned int i=0; i<nTags; i++){
    if ((tag_table[i].tag!=0x0) && (tag_table[i].description!=NULL)){
      // valid tag
      this->push_back(ExifTag(tag_table[i].tag,
                  tag_table[i].description) );
    };
  };
}

// JW
int ImageAttributes::Read(const std::string & filename){
  return ReadMagickPP(filename);
}


// JW
int ImageAttributes::ReadMagickPP(const std::string & filename){
    if(BIAS::FileHandling::Extension(filename) == "mip")
        return -3;

#ifndef BIAS_HAVE_IMAGEMAGICKLIB
  BIASERR("BIAS_HAVE_IMAGEMAGICKLIB not defined. Please recompile BIAS with USE_IMAGEMAGICK enabled to load "<<filename);
  return -2;
#else
  try {
# ifdef WIN32
    // initialize DLL loaded library (not required on Linux but once on Windows)
    Magick::InitializeMagick(NULL);
# endif
    Magick::Image img;
    // get image header data without reading the raw image data:
    img.ping(filename);
    return ReadMagickPP(img); // OK so far
  } catch ( Magick::Exception &error_ ) {
    BIASERR("Getting Image attributes from "<<filename<<" with Magick++ failed."<<endl
      <<"  Caught exception: "<<endl
      <<"  "<<error_.what()<<endl );
    return -1; // error
  } catch (...) {
    BIASERR("Getting Image attributes from "<<filename<<" with Magick++ failed."<<endl
      <<"  Caught unspecied (...) exception."<<endl);
    return -2; // error
  };
#endif
}

// JW
#ifdef BIAS_HAVE_IMAGEMAGICKLIB
int ImageAttributes::ReadMagickPP(Magick::Image & img){
  try {
    ImageAttributes::iterator it;
    string name;
    string val;
    unsigned int index = 0;
    for (it=this->begin(); it!=this->end(); it++, index++){
      name  = "EXIF:";
      name += it->name;
      val=img.attribute(name);
      if (it->GoodValue( val )){
    it->value = val;
    mapValidTags_[it->name]=index;
    //cout<<"Found tag "<<it->name<<" with value "<<it->value<<endl;
    //} else {
    //COUT("skipped EXIF tag "<<it->name<<". invalid value= "<<it->value<<endl);
      };
    };

  } catch ( Magick::Exception &error_ ) {
    BIASERR("Getting Image attributes from Magick::Image with Magick++ failed."<<endl
        <<"  Caught exception: "<<endl
        <<"  "<<error_.what()<<endl );
    return -1; // error
  } catch (...) {
    BIASERR("Getting Image attributes from Magick::Image with Magick++ failed."<<endl
        <<"  Caught unspecified (...) exception."<<endl );
    return -2; // error
  };
  return BIAS_IMAGEATTRIBUTES_SUCCESS; // OK
}
#endif


std::ostream& ImageAttributes::Print(std::ostream& os,
                     const bool printAll) const
{
  os<<"ImageAttributes: size="<<this->size()<<endl;
  ImageAttributes::const_iterator it=this->begin();
  for (it=this->begin(); it!=(this->end()); it++){
    if (printAll || it->GoodValue(it->value) ) {
      it->Print(os);
      os<<endl;
      //} else {os<<"skipped "<<it->name<<endl;
    };
  };
  return os;
}


std::ostream& operator<<(std::ostream& os,
             const BIAS::ImageAttributes &attr)
{
  return attr.Print(os);
}


bool ImageAttributes::GetString_(const string& key, string& value) {
    map<string, unsigned int>::iterator it;
    if ((it = mapValidTags_.find(key))==mapValidTags_.end()) {
    BIASDOUT(D_EXIF,"failed to find "<<key);
    return false;
    }
    value = (*this)[it->second].value;
    BIASDOUT(D_EXIF,"Found "<<key<<"="<<value);
    return true;
}

bool ImageAttributes::GetRational_(const string& key, double& value) {
    string thevalue;
    if (!GetString_(key, thevalue)) return false;
    string::size_type slashpos = thevalue.find('/');
    string second, first = thevalue.substr(0, slashpos);
    if (slashpos>=0 && slashpos<(string::size_type)thevalue.size()-1)
    second = thevalue.substr(slashpos+1,thevalue.size()-1);
    double dfirst = atof(first.c_str());
    double dsecond = atof(second.c_str());
    value = dfirst/dsecond;
    return true;
}

bool ImageAttributes::GetShort_(const string& key, int& value){
    string thevalue;
#ifdef WIN32
 # ifdef max
 #   undef max
 #  endif // max
#endif //WIN32

    if (!GetString_(key,thevalue)) return false;
    value = numeric_limits<int>::max();
    value = atoi(thevalue.c_str());
    if (value==numeric_limits<int>::max()) return false;
    return true;
}


int ImageAttributes::GetFocalLengthMeter(double &fm) {
    if (!GetRational_("FocalLength",fm)) return -1;
    // milli meter to meter
    fm *= 0.001;
    BIASDOUT(D_EXIF, "focal length in meter is "<<fm);
    return 0;
}


int ImageAttributes::GetFocalLengthXPixel(double &fp) {
    int res = GetFocalLengthMeter(fp);
    if (res<0) return res;
    double pixelsize;
    res = GetPixelSizeXMeter(pixelsize);
    if (res<0) return res;
    fp /= pixelsize;
    BIASDOUT(D_EXIF, "FocalLengthXPixel is "<<fp);
    return res;
}

int ImageAttributes::GetFocalLengthYPixel(double &fp) {
    int res = GetFocalLengthMeter(fp);
    if (res<0) return res;
    double pixelsize;
    res = GetPixelSizeYMeter(pixelsize);
    if (res<0) return res;
    fp /= pixelsize;
    BIASDOUT(D_EXIF, "FocalLengthYPixel is "<<fp);
    return res;
}

int ImageAttributes::GetPixelSizeXMeter(double &p) {
    if (!GetRational_("FocalPlaneXResolution", p)) return -1;
    BIASDOUT(D_EXIF, "FocalPlaneXResolution is "<<p);
    int unit = 0;
    if (!GetShort_("FocalPlaneResolutionUnit", unit)) return -1;
    switch (unit) {
    case 2: // Inch.
        p = METER_PER_INCH / p;
        break;
    case 3: // Centimeter.
        p = 0.01 / p;
        break;
    case 1: // No absolute unit of measurement.
    default:// unknown unit
        return 1;
        break;
    }

 return 0;
}
int ImageAttributes::GetPixelSizeYMeter(double &p) {
    if (!GetRational_("FocalPlaneYResolution", p)) return -1;
    BIASDOUT(D_EXIF, "FocalPlaneYResolution is "<<p);
    int unit = 0;
    if (!GetShort_("FocalPlaneResolutionUnit", unit)) return -1;
    switch (unit) {
    case 1: // No absolute unit of measurement.
        return 1;
        break;
    case 2: // Inch.
        p = METER_PER_INCH / p;
        break;
    case 3: // Centimeter.
        p = 0.01 / p;
        break;
    default: // unknown unit
        return -1;
    }

 return 0;
}


int ImageAttributes::GetFieldOfViewDegree(double &x, double& y) {
    int width, height;
    double fp;
    if (GetImageDimensions(width, height)!=0) return -1;
    if (GetFocalLengthXPixel(fp)<0) return -2;
    x = 180.0/M_PI *2.0*atan(double(width)/(2.0*fp));
    if (GetFocalLengthYPixel(fp)<0) return -3;
    y = 180.0/M_PI *2.0*atan(double(height)/(2.0*fp));

    return 0;
}


int ImageAttributes::GetImageDimensions(int& width, int& height) {
    if (!GetShort_("ImageWidth", width)) {
    if (!GetShort_("ExifImageWidth", width)) {
        return -1;
    }
    if (!GetShort_("ExifImageLength", height)) {
        return -1;
    }
    return 0;
    }
    if (!GetShort_("ImageLength", height)) return -1;
    return 0;
}


int ImageAttributes::GetPrincipalPoint(double& x, double& y) {
    int width, height;
    if (GetImageDimensions(width, height)!=0) return -1;
    x = double(width-1)/2.0;
    y = double(height-1)/2.0;
    return 1;
}

int ImageAttributes::GetHardwareName(string& Make, string& Model){
    Make = "";
    Model = "";
    int res = 0;
    if (!GetString_("Make",Make)) res -= 1;
    if (!GetString_("Model",Model)) res -= 2;
    return res;
}


std::string ImageAttributes::GetIdentifier()
{
  string id,tmp;
  if (GetString_("Make",tmp) ) id += tmp;
  else id += "Unknown";
  id +=" ";
  if (GetString_("Model",tmp) ) id += tmp;
  else id += "Unknown";
  double focalmeter;
  GetFocalLengthMeter(focalmeter);
  ostringstream oss;
  oss<<focalmeter*1000;
  id += " "+oss.str()+"mm";
  return id;


}