Camera.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <Base/Common/BIASpragma.hh>

#define _CRT_SECURE_NO_DEPRECATE
#include <stdio.h>

#include <Base/Image/Image.hh>
#include "Camera.hh"
#define MAXHEADERLINES 1024

using namespace BIAS;
using namespace std;

template <class StorageType>
void Camera<StorageType>::Init_(){
  TimeSec_ = 0;
  TimeUSec_ = 0;
  Orientation_[0] = 0.0;
  Orientation_[1] = 0.0;
  Orientation_[2] = 0.0;
  _f=0.0;
  _C.Set(0.0, 0.0, 0.0);
  _K.SetZero();
  P_.SetZero();
  _R.SetIdentity();
  _Point.Set(0.0,0.0,0.0);
  // set all valid flags to false
  TimeValid_        = false;
  ASCIIValid_       = false;
  OrientationValid_ = false;
  PValid_           = false;
  KValid_           = false;
  RValid_           = false;
  CValid_           = false;
  PointValid_       = false;
  fValid_           = false;
  ProjValid_        = false;
//#ifdef BIAS_DAIMLERCHRYSLER
  ptuValid_         = false;
  inertialValid_    = false;
  gpsValid_         = false;
//#endif

}

template <class StorageType>
Camera<StorageType>::Camera() : Image<StorageType>()
{
  Init_();
}

template <class StorageType>
Camera<StorageType>::~Camera()
{}

template <class StorageType>
Camera<StorageType>::Camera(const ImageBase& img)
  : Image<StorageType>(img)
{
  Init_();
}

template <class StorageType>
void Camera<StorageType>::PrintAppData(ostream &os)
{
  if (ASCIIValid_) os << "ASCII  : "<<ASCIIString_<<endl;
  if (IsTimeValid()) os << "Timestamp   : "<<TimeSec_<<":"<<TimeUSec_<<endl;
  if (IsOrientationValid())
    os << "Orientation : "<<Orientation_[0]<<" "<<Orientation_[1]<<" "
       <<Orientation_[2]<<endl;
  if (IsPValid()) os << "P-Matrix: " << endl << P_;

  bool isPDecomposable = IsPValid() && (P_.NormFrobenius() > 1E-50);

  // axis/angle representation of R-Matrix
  bool hasRMatrix = false;
  Vector3<ROTATION_MATRIX_TYPE> RAxis;
  ROTATION_MATRIX_TYPE RAngle=0;
  Quaternion<double> Q;

  if (IsRValid()) {
    os << "R-Matrix: " << endl << _R;
    _R.GetRotationAxisAngle(RAxis, RAngle);
    _R.GetQuaternion(Q);
    hasRMatrix = true;
  } else {
    if (isPDecomposable) {
      os << "R-Matrix is empty - decomposed from P: " << endl << P_.GetR();
      RMatrix(P_.GetR()).GetRotationAxisAngle(RAxis, RAngle);
      RMatrix(P_.GetR()).GetQuaternion(Q);
      hasRMatrix = true;
    }
  }
  if (hasRMatrix) {
    RAngle = (RAngle / M_PI) * 180.0; // convert angle to degrees
    os << "[Axis, Angle] = [("
       << RAxis[0] << ", "
       << RAxis[1] << ", "
       << RAxis[2] << "), "
       << RAngle << " deg]" << endl;
    os << "Quaternion: ["<<Q[0]<< ", "
       << Q[1] << ", "
       << Q[2] << ", "
       << Q[3] << "]\n";
  }
  if (IsKValid()) {
    os << "K-Matrix: " << endl << _K;
  } else {
    if (isPDecomposable)
      os << "K-Matrix is empty - decomposed from P: " << endl << P_.GetK();
  }
  if (IsCValid()) {
    os << "C-Vector: " << _C << endl;
  } else {
    if (isPDecomposable)
      os << "C-Vector is empty - decomposed from P: " << P_.GetC() << endl;
  }
  if (IsPointValid()) os << "HomgPoint2D: " << _Point << endl;
  if (IsfValid()) os << "Focal length: "<< _f << endl;
  if (IsProjValid()) os<<"Projection: "<<Proj_<<endl;
  os<<"RefUUID: "<<RefUUID_<<endl;
//#ifdef BIAS_DAIMLERCHRYSLER
  if (IsptuValid()) os << ptu << endl;
  if (IsinertialValid()) os << inertial << endl;
  if (IsgpsValid()) os << gps << endl;
//#endif
}


template <class StorageType>
int Camera<StorageType>::ParseMetaData(bool bUse2x64bitTS)
{
  // reset all haveXXX fields to avoid mixing "old meta data" with current
  Init_();
  int res = 0;
  setlocale(LC_ALL, "C");//enforce C locales
  AppData ad;
  //SetDebugLevel(GetDebugLevel() | D_CAMERA_METADATA);

  BIASDOUT(D_CAMERA_METADATA, "_MetaData has " << this->_MetaData.size()
           << " entries");

  if (this->_MetaData.Find(AppData::MD_ASCII_DATA, "#[ASCII]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found ASCII String");
    if (ad.tag==AppData::MD_USE_ASCII){
      ASCIIString_ = ad.sdata;
    }
    else{
      ASCIIString_="";
      for(int i=0; i<ad.length; i++){
        ASCIIString_+=ad.data[i];
      }
    }
    ASCIIValid_=true;
  }

  if (this->_MetaData.Find(AppData::MD_Projection, "#[Projection]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found Projection");
    string flatproj;
    if (ad.tag==AppData::MD_USE_ASCII) flatproj = ad.sdata;

    else {
      char *tmp = new char[ad.length+1];
      memcpy(tmp, ad.data, ad.length);
      tmp[ad.length] = 0;
      flatproj = tmp;
      //flatproj = flatproj.substr(0,ad.length);
      delete[] tmp;
      //cout << flatproj;
    }
#ifdef BIAS_HAVE_XML2
    int res = Proj_.XMLReadFromString(flatproj);
    if (res<0)
      BIASERR("Failed to parse string with length: "<<ad.length<<" string: "
              <<flatproj);
    ProjValid_=true;
    //Proj_.GetParameters()->ValidatePose();
    if(!Proj_.GetParameters()->PoseValid()) {
      BIASERR("returning invalid pose!");
      res = -1;
    }
#endif //BIAS_HAVE_XML2
  }

  if (this->_MetaData.Find(AppData::MD_PMatrix, "#[PMatrix]", ad)>=0){
    PMatrix P;
    BIASDOUT(D_CAMERA_METADATA, "found PMatrix");
    if (ad.tag==AppData::MD_USE_ASCII){
      sscanf(ad.sdata.c_str(),
             "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
             &P[0][0], &P[0][1], &P[0][2], &P[0][3],
             &P[1][0], &P[1][1], &P[1][2], &P[1][3],
             &P[2][0], &P[2][1], &P[2][2], &P[2][3]);
    } else {
      memcpy(P.GetData(), ad.data, ad.length);
    }
    if (P.NormL2()>1e-9) {
      P_ = P;
      PValid_=true;

      // ----------------- copy "deprecated" pmatrix from old ---------------
      // ------- images into new projection, if image has no projection ------
      if (!ProjValid_) {
        ProjectionParametersPerspective PPP;
        PPP.SetImageSize(this->GetWidth(), this->GetHeight());
        PPP.SetP(P);
        Proj_ = Projection(PPP);
        ProjValid_=true;
      }
    } else {
      BIASWARN("ignored zero PMatrix in meta data.");
    }
  }

  if (this->_MetaData.Find(AppData::MD_TimeStamp, "#[TimeStamp]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found TimeStamp");
    if (bUse2x64bitTS) {
      if (ad.tag==AppData::MD_USE_ASCII){
        sscanf(ad.sdata.c_str(), "%llu %llu " , &TimeSec_, &TimeUSec_);
      } else {
        //TimeSec_ = ((long int*)ad.data)[0];
        //TimeUSec_ = ((long int*)ad.data)[1];
        TimeSec_  = ((unsigned long long int*)ad.data)[0];
        TimeUSec_ = ((unsigned long long int*)ad.data)[1];
      }
    } else {
      if (ad.tag==AppData::MD_USE_ASCII){
        int tSec = 0, tUSec = 0;
        sscanf(ad.sdata.c_str(), "%d %d " , &tSec, &tUSec);
        TimeSec_ = (unsigned long long int) tSec;
        TimeUSec_ = (unsigned long long int) tUSec;
      } else {
        TimeSec_  = (unsigned long long int) ((int*)ad.data)[0];
        TimeUSec_ = (unsigned long long int) ((int*)ad.data)[1];
      }
    }
    TimeValid_=true;
  }
  if (this->_MetaData.Find(AppData::MD_Orientation, "#[Orientation]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found Orientation");
    if (ad.tag==AppData::MD_USE_ASCII){
      sscanf(ad.sdata.c_str(), "%f %f %f" ,&Orientation_[0], &Orientation_[1],
             &Orientation_[2]);
    } else {
      memcpy(&Orientation_, ad.data, ad.length);
    }
    OrientationValid_=true;
  }
  if (this->_MetaData.Find(AppData::MD_CVector, "#[CVector]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found CVector");
    if (ad.tag==AppData::MD_USE_ASCII){
      sscanf(ad.sdata.c_str(), "%lf %lf %lf ", &_C[0], &_C[1], &_C[2]);
    } else {
      memcpy(_C.GetData(), ad.data, ad.length);
    }
    CValid_=true;
  }
  if (this->_MetaData.Find(AppData::MD_RMatrix, "#[RMatrix]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found RMatrix");
    if (ad.tag==AppData::MD_USE_ASCII){
      sscanf(ad.sdata.c_str(), "%lf %lf %lf %lf %lf %lf %lf %lf %lf",
             &_R[0][0], &_R[0][1], &_R[0][2],
             &_R[1][0], &_R[1][1], &_R[1][2],
             &_R[2][0], &_R[2][1], &_R[2][2]);
    } else {
      memcpy(_R.GetData(), ad.data, ad.length);
    }
    RValid_=true;
  }
  if (this->_MetaData.Find(AppData::MD_KMatrix, "#[KMatrix]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found KMatrix");
    if (ad.tag==AppData::MD_USE_ASCII){
      sscanf(ad.sdata.c_str(), "%lf %lf %lf %lf %lf %lf %lf %lf %lf",
             &_K[0][0], &_K[0][1], &_K[0][2],
             &_K[1][0], &_K[1][1], &_K[1][2],
             &_K[2][0], &_K[2][1], &_K[2][2]);
    } else {
      memcpy(_K.GetData(), ad.data, ad.length);
    }
    KValid_=true;
  }
  if (this->_MetaData.Find(AppData::MD_HomgPoint2D, "#[HomgPoint2D]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found HomgPoint2D");
    if (ad.tag==AppData::MD_USE_ASCII){
      sscanf(ad.sdata.c_str(), "[ %lf %lf %lf ]",
             &_Point[0], &_Point[1], &_Point[2]);
    } else {
      memcpy(_Point.GetData(), ad.data, ad.length);
    }
    PointValid_=true;
  }
  if (this->_MetaData.Find(AppData::MD_Focal_Length, "#[Focal Length]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found Focal Length");
    if (ad.tag==AppData::MD_USE_ASCII){
      sscanf(ad.sdata.c_str(), "%lf", &_f);
    } else {
      memcpy(&_f, ad.data, ad.length);
    }
    fValid_=true;
  }
  if (this->_MetaData.Find(AppData::MD_RefUUID, "#[Reference UUID]", ad)>=0){
    if (ad.tag==AppData::MD_USE_ASCII){
      RefUUID_.SetFromString(ad.sdata);
    } else {
      string uids;
      char  * tmpstring = new char[ad.length+1];
      tmpstring[ad.length]=0;
      memcpy(tmpstring, ad.data, ad.length);
      RefUUID_.SetFromString(tmpstring);
      delete[] tmpstring;
    }
    BIASDOUT(D_CAMERA_METADATA, "found Reference UUID: "<<RefUUID_);

  }
//#ifdef BIAS_DAIMLERCHRYSLER
  if (this->_MetaData.Find(AppData::MD_PTU_Data, "#[PTU Data]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found PTU_Data");
    if (ad.tag==AppData::MD_USE_ASCII){
      stringstream ss;
      ss << ad.sdata;
      ss >> ptu;
    } else {
      //memcpy(&ptu, ad.data, ad.length);
      ptu.ReadBinary(ad.data);
    }
    BIASDOUT(D_CAMERA_METADATA, "cam.ptu: "<<ptu<<endl);
    ptuValid_=true;
  }
  if (this->_MetaData.Find(AppData::MD_Inertial_Sensor,"#[Inertial Sensor]",
                           ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found Inertial_Sensor");
    if (ad.tag==AppData::MD_USE_ASCII){
      stringstream ss;
      ss << ad.sdata;
      ss >> inertial;
    } else {
      //memcpy(&inertial, ad.data, ad.length);
      inertial.ReadBinary(ad.data);
    }
    BIASDOUT(D_CAMERA_METADATA, "cam.inertiual: "<<inertial<<endl);
    inertialValid_=true;
  }
  if (this->_MetaData.Find(AppData::MD_Inertial_Sensor,"#[GPS Data]", ad)>=0){
    BIASDOUT(D_CAMERA_METADATA, "found GPS Data");
    if (ad.tag==AppData::MD_USE_ASCII){
      stringstream ss;
      ss << ad.sdata;
      ss >> gps;
    } else {
      gps.ReadBinary(ad.data);
    }
    BIASDOUT(D_CAMERA_METADATA, "cam.gps: "<<gps<<endl);
    gpsValid_=true;
  }
//#endif // BIAS_DAIMLERCHRYSLER

  /*
    if (this->_MetaData.Find(AppData::MD_, "#[]", ad)>=0){
      BIASDOUT(D_CAMERA_METADATA, "found ");
      if (ad.tag==AppData::MD_USE_ASCII){
        sscanf(ad.sdata.c_str(), );
      } else {
        BEXCEPTION("Not implemented yet!");
      }
    }
  */
  return res;
}

template <class StorageType>
Camera<StorageType>::Camera(const Camera<StorageType> &src)
{
  this->operator=(src);
}



template <class StorageType>
Camera<StorageType>&
Camera<StorageType>::operator=(const Camera<StorageType> &src)
{
  this->Image<StorageType>::operator=(src);
   TimeSec_=src.TimeSec_;
  TimeUSec_=src.TimeUSec_;
  Orientation_[0] = src.Orientation_[0];
  Orientation_[1] = src.Orientation_[1];
  Orientation_[2] = src.Orientation_[2];
  P_=src.P_;
  _K=src._K;
  _R=src._R; // rotation of camera
  _C=src._C; // camera center in world coo
  _Point=src._Point;
  _f=src._f;
  Proj_=src.Proj_;
  RefUUID_=src.RefUUID_;
//#ifdef BIAS_DAIMLERCHRYSLER
  ptu=src.ptu;
  inertial=src.inertial;
  gps=src.gps;
//#endif

  // copy all the valid flags
  TimeValid_        = src.TimeValid_ ;
  OrientationValid_ = src.OrientationValid_;
  PValid_           = src.PValid_ ;
  KValid_           = src.KValid_ ;
  RValid_           = src.RValid_;
  CValid_           = src.CValid_;
  PointValid_       = src.PointValid_;
  fValid_           = src.fValid_;
  ProjValid_=src.ProjValid_;

//#ifdef BIAS_DAIMLERCHRYSLER
  ptuValid_         = src.ptuValid_;
  inertialValid_    = src.inertialValid_;
  gpsValid_         = src.gpsValid_;
//#endif
  return (*this);
}


template <class StorageType>
int Camera<StorageType>::UpdateMetaData()
{
  setlocale(LC_ALL, "C");//enforce C locales
  //AddDebugLevel(D_CAMERA_METADATA);
  char tmpline[2048];
  ostringstream os;
  BIASDOUT(D_CAMERA_METADATA,"UpdateMetaData()");
  if(ASCIIValid_)
    {
      this->_MetaData.Add(AppData::MD_ASCII_DATA, ASCIIString_.size(),
              (char*)ASCIIString_.c_str());
      this->_MetaData.Add("#[ASCII]", ASCIIString_);
      BIASDOUT(D_CAMERA_METADATA,"Added ASCII String");
    }
  if (PValid_) {
    this->_MetaData.Add(AppData::MD_PMatrix, 12*sizeof(double),
                        (char*)P_.GetData());
    sprintf(tmpline, "%.30g %.30g %.30g %.30g %.30g %.30g %.30g %.30g %.30g %.30g %.30g %.30g",
            P_[0][0], P_[0][1], P_[0][2], P_[0][3],
            P_[1][0], P_[1][1], P_[1][2], P_[1][3],
            P_[2][0], P_[2][1], P_[2][2], P_[2][3]);
    this->_MetaData.Add("#[PMatrix]", tmpline);
    BIASDOUT(D_CAMERA_METADATA,"Added PMatrix");
  }
  if (TimeValid_) {
    //long int time[2];
    unsigned long long int time[2];
    time[0] = TimeSec_;
    time[1] = TimeUSec_;
    this->_MetaData.Add(AppData::MD_TimeStamp,sizeof(time),(char*)time);
    sprintf(tmpline, "%llu %llu" , TimeSec_, TimeUSec_);
    this->_MetaData.Add("#[TimeStamp]", tmpline);
    BIASDOUT(D_CAMERA_METADATA,"Added Time");
  }
  if (OrientationValid_) {
    this->_MetaData.Add(AppData::MD_Orientation, sizeof(Orientation_),
                        (char*)Orientation_);
    sprintf(tmpline, "%.30f %.30f %.30f" , Orientation_[0], Orientation_[1],
            Orientation_[2]);
    this->_MetaData.Add("#[Orientation]", tmpline);
    BIASDOUT(D_CAMERA_METADATA,"Added Orientation");
  }
  if (CValid_){
    this->_MetaData.Add(AppData::MD_CVector, 3*sizeof(double),
                        (char*)_C.GetData());
    sprintf(tmpline, "%.30g %.30g %.30g ", _C[0], _C[1], _C[2]);
    this->_MetaData.Add("#[CVector]", tmpline);
    BIASDOUT(D_CAMERA_METADATA,"Added CVector");
  }
  if (RValid_) {
    this->_MetaData.Add(AppData::MD_RMatrix, 9*sizeof(double),
                        (char*)_R.GetData());
    sprintf(tmpline, "%.30g %.30g %.30g %.30g %.30g %.30g %.30g %.30g %.30g",
            _R[0][0], _R[0][1], _R[0][2],
            _R[1][0], _R[1][1], _R[1][2],
            _R[2][0], _R[2][1], _R[2][2]);
    this->_MetaData.Add("#[RMatrix]", tmpline);
    BIASDOUT(D_CAMERA_METADATA,"Added RMatrix");
  }
  if (KValid_) {
    this->_MetaData.Add(AppData::MD_KMatrix, 9*sizeof(double),
                        (char*)_K.GetData());
    sprintf(tmpline, "%.30g %.30g %.30g %.30g %.30g %.30g %.30g %.30g %.30g",
            _K[0][0], _K[0][1], _K[0][2],
            _K[1][0], _K[1][1], _K[1][2],
            _K[2][0], _K[2][1], _K[2][2]);
    this->_MetaData.Add("#[KMatrix]", tmpline);
    BIASDOUT(D_CAMERA_METADATA,"Added KMatrix");
  }
  if (fValid_){
    this->_MetaData.Add(AppData::MD_Focal_Length, sizeof(double),
                        (char*)&_f);
    sprintf(tmpline, "%.30g", _f);
    this->_MetaData.Add("#[Focal Length]", tmpline);
    BIASDOUT(D_CAMERA_METADATA,"Added Focal Length");
  }
  if (ProjValid_) {
    string flatproj ;
#ifdef BIAS_HAVE_XML2
    Proj_.XMLWriteToString(flatproj);
#endif //BIAS_HAVE_XML2
    for (unsigned int i=0;i<flatproj.length(); i++) {
      if (flatproj[i] == 10) flatproj[i] = 32;
      if (flatproj[i] == 13) flatproj[i] = 32;
    }
    this->_MetaData.Add(AppData::MD_Projection, flatproj.length(),
                        (char*)flatproj.c_str());

    this->_MetaData.Add("#[Projection]", flatproj.c_str());
    BIASDOUT(D_CAMERA_METADATA,"Added Projection");

  } //Proj_

  if (RefUUID_.IsValid()) {
    string uids=RefUUID_.GetString();
    this->_MetaData.Add(AppData::MD_RefUUID,uids.length(),(char*)uids.c_str());
    this->_MetaData.Add("#[Reference UUID]", uids);
    BIASDOUT(D_CAMERA_METADATA,"Added Reference UUID: "<<uids);

  }

//#ifdef BIAS_DAIMLERCHRYSLER
  //this->AddDebugLevel(D_CAMERA_METADATA);
  char *tmpdata = NULL;
  int length=0;
  if (ptuValid_) {
    length=ptu.GetBinaryLength();
    tmpdata=new char[length+1];
    BIASCDOUT(D_CAMERA_METADATA, "allocated memory: "<<(void *)tmpdata<<endl);
    ptu.WriteBinary(tmpdata);
    BIASCDOUT(D_CAMERA_METADATA, *(double*)tmpdata<<endl);
    this->_MetaData.Add(AppData::MD_PTU_Data, length, tmpdata);
    BIASDOUT(D_CAMERA_METADATA,"Added PTU Data");
    os.str("");
    os << ptu;
    BIASDOUT(D_CAMERA_METADATA,"ptu "<<os.str());
    this->_MetaData.Add("#[PTU Data]", os.str());
    BIASDOUT(D_CAMERA_METADATA,"Added string PTU Data");
    BIASCDOUT(D_CAMERA_METADATA, "attempting to free memory: "
              <<(void *)tmpdata<<endl);
    delete[] tmpdata; tmpdata=NULL;
  }
  if (inertialValid_){
    length=inertial.GetBinaryLength();
    tmpdata=new char[length+1];
    inertial.WriteBinary(tmpdata);
    this->_MetaData.Add(AppData::MD_Inertial_Sensor, length, tmpdata);
    os.str("");
    os << inertial;
    this->_MetaData.Add("#[Inertial Sensor]", os.str());
    BIASDOUT(D_CAMERA_METADATA,"Added Inertial Sensor");
    delete[] tmpdata; tmpdata=NULL;
  }
  if (gpsValid_){
    length=gps.GetBinaryLength();
    tmpdata=new char[length+1];
    gps.WriteBinary(tmpdata);
    this->_MetaData.Add(AppData::MD_GPS_Data, length, tmpdata);
    os.str("");
    os << gps;
    this->_MetaData.Add("#[GPS Data]", os.str());
    BIASDOUT(D_CAMERA_METADATA,"Added GPS Data");
    delete[] tmpdata; tmpdata=NULL;
  }
//#endif // BIAS_DAIMLERCHRYSLER

  BIASDOUT(D_CAMERA_METADATA,"Finished adding meta data");
  return 0;
}


// template instantiation

#define INST(type)\
template class BIASImage_EXPORT Camera<type>
//template ostream& operator<<<type>(ostream & , Image<type> const & );
//template istream& operator>><type>(istream& , Image<type>& );

namespace BIAS{
INST(unsigned char);
INST(float);

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