PMDImageIO.hh

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

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


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

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

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

#ifndef __BIAS_PMDIMAGEIO_H__
#define __BIAS_PMDIMAGEIO_H__

#include <bias_config.h>

#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 PMD multi plane tiff.
#endif
#endif //BIAS_HAVE_TIFF

#include <string>
#include <Base/Image/Image.hh>

#ifdef BIAS_HAVE_XML2
#  include <Base/Common/XMLIO.hh>
#endif


#ifdef BIAS_HAVE_TIFF
// Define user specific TIFF-Tags
  
/* tags 33550 is a private tag registered to SoftDesk, Inc */
#define TIFFTAG_PRINCIPALPOINT  33550
/* tags 33920-33921 are private tags registered to Intergraph, Inc */
#define TIFFTAG_FOCALLENGTHX    33920
#define TIFFTAG_ASPECTRATIO     33921
/* tags 34263-34264 are private tags registered to NASA-JPL Carto Group */
#define TIFFTAG_UNDISTORTION    34263  
/* tags 34735-3438 are private tags registered to SPOT Image, Inc */
#define TIFFTAG_CAMERACENTER    34736
#define TIFFTAG_CAMERAROTATION  34737
#endif //BIAS_HAVE_TIFF


namespace BIAS {

  /** @struct PMDImageMetaData
      @brief Store extrinsic and intrinsic camera parameters for 
      Rotation is in axis * angle representation
      image padding and Metadata.
      @author streckel 02/2006
  */
  struct BIASImage_EXPORT PMDImageMetaData {
    unsigned int width;
    unsigned int height;
    unsigned int channels;
    double PrincipalX;
    double PrincipalY;
    double FocallengthX;
    double AspectRatio;
    double UndistCoeff[4];
    double CameraCenter[3];
    double CameraRotation[3];
  };

#ifdef BIAS_HAVE_TIFF  
  /** @class PMDImageIO
      @ingroup g_image_base
      @brief Save 2D/3D-image-data together with some metadata in a
      single tiff-datafile. The 2D-3D-data is aligned, such that for
      each pixel in the 2D-image the corresponding depth is 
      stored at the same position in the depth image. A -1 in the depth 
      image indicates that no depth data is available.
      @author streckel 02/2006 */
  
  class BIASImageBase_EXPORT PMDImageIO {
  public:
    
    /** @brief Save a PMD-data 2d/3d-tiff image to disk
        @param FileName Output filename, should have the extension .tif
        @param Img2D pointer to the 2d-image data to save, if NULL only 
        depth is written, metadata is also ignored
        @param ImgDepth  pointer to the depth data to save, if NULL only 
        2D-img is written, metadata is also ignored
        @param MetaData2D the Metadata of the 2D-image to save
        @param MetaDataDepth the Metadata of the depth image to use for padding
        @author Birger Streckel **/
    static int Save(const std::string& FileName, 
                     uint8* Img2D, uint16* ImgDepth, 
                     uint16* ImgModCoeff,
                     const PMDImageMetaData &MetaData2D,
                     const PMDImageMetaData &MetaDataDepth);
    static int Save(const std::string& FileName, 
                     uint16* Img2D, uint16* ImgDepth, 
                     uint16* ImgModCoeff,
                     const PMDImageMetaData &MetaData2D,
                     const PMDImageMetaData &MetaDataDepth);
  
    /** @brief Save a PMD-data 2d/3d-tiff image to disk
        @param FileName Output filename, should have the extension .tif
        @param img the 2d-image data to save
        @param depthimg the depth data to save
        @param MetaData2D the Metadata of the 2D-image to save
        @param MetaDataDepth the Metadata of the depth image to use for padding
        @author Birger Streckel **/
    static int Save(const std::string& FileName, 
                     BIAS::Image<unsigned char> &Img2D, 
                     BIAS::Image<float> &ImgDepth, 
                     BIAS::Image<float> &ImgModCoeff, 
                     PMDImageMetaData &MetaData2D,
                     PMDImageMetaData &MetaDataDepth);
    
    /** @brief Load a PMD-data 2d/3d-tiff image from disk
        @param FileName complete name of file to be loaded
        @param Img2D to receive the 2d-image data from the file, 
        new memory is allocated, if NULL tif contained no 2D-image
        @param ImgDepth to receive the depth-image data from the file, 
        new memory is allocated, if NULL tif contained no depth-image
        @param MetaData to receive the Metadata from the file
        @author Birger Streckel **/
    static int Load(const std::string& FileName, 
                    uint8* &Img2D, uint16* &ImgDepth, 
                    uint16* &ImgModCoeff,
                    PMDImageMetaData &MetaData2D, 
                    PMDImageMetaData &MetaDataDepth);    
    static int Load(const std::string& FileName, 
                    uint16* &Img2D, uint16* &ImgDepth, 
                    uint16* &ImgModCoeff,
                    PMDImageMetaData &MetaData2D, 
                    PMDImageMetaData &MetaDataDepth);    
  
    
    /** @brief Load a PMD-data 2d/3d-image from disk, automatically detecting 
        TIFF or XML file format and calling the appropriate subroutine.
        @param FileName complete name of file to be loaded
        @param img to receive the 2d-image data from the file
        @param depthimg to receive the depth-image data from the file
        @param MetaData to receive the Metadata from the file
        @author Birger Streckel **/
    static int Load(const std::string& FileName, 
                    Image<unsigned char> &Img2D, 
                    Image<float> &ImgDepth, 
                    Image<float> &ImgModCoeff, 
                    PMDImageMetaData &MetaData2D, 
                    PMDImageMetaData &MetaDataDepth);

    /** @brief Load a PMD-data 2d/3d-image from TIFF-file.
        @author Birger Streckel
    */
    static int LoadFromTIFF(const std::string& FileName, 
                            Image<unsigned char> &Img2D, 
                            Image<float> &ImgDepth, 
                            Image<float> &ImgModCoeff, 
                            PMDImageMetaData &MetaData2D, 
                            PMDImageMetaData &MetaDataDepth);
    
    /** @brief Load PMD-image from 3 space separated text files.
        @author Birger Streckel
    */
    static int LoadFromTXT(int width, int height,
                           const std::string& FileName2D, 
                           const std::string& FileNameDepth, 
                           const std::string& FileNameModCoeff, 
                           Image<unsigned char> &Img2D, 
                           Image<float> &ImgDepth, 
                           Image<float> &ImgModCoeff, 
                           PMDImageMetaData &MetaDataDepth);
    
#ifdef BIAS_HAVE_XML2
    /** @brief Load a PMD-data 2d/3d-image from PMDtec's XMK format.
        The 1st image is Load if the file contains a sequence.
        @author Birger Streckel
    */
    static int LoadFromXML(const std::string& FileName, 
                           Image<unsigned char> &Img2D, 
                           Image<float> &ImgDepth, 
                           Image<float> &ImgModCoeff, 
                           PMDImageMetaData &MetaData2D, 
                           PMDImageMetaData &MetaDataDepth);

    static int LoadFromXML(const std::string& FileName, 
                           std::vector<Image<unsigned char> > &Imgs2D, 
                           std::vector<Image<float> > &ImgDepth, 
                           std::vector<Image<float> > &ImgModCoeff, 
                           std::vector<PMDImageMetaData> &MetaData2D, 
                           std::vector<PMDImageMetaData> &MetaDataDepth);
 
    /** @brief Load a PMD-image in the PMD-technologies XML-format from disk
        for a specification see the CamVis Pro instruction manual. Data from 
        tag <grayscale> is Load to Img2D, <distance> is Load to ImgDepth and
        <amplitude> is Load to ImgModCoeff. All other tags <rawXY> are 
        ignored. Is a sequence is given, only the first image is Load.
        @param FileName complete name of file to be loaded
        @param Img2D to receive the 2d-image data from the file, 
        new memory is allocated, if NULL tif contained no 2D-image
        @param ImgDepth to receive the depth-image data from the file, 
        new memory is allocated, if NULL tif contained no depth-image
        @param MetaData to receive the Metadata from the file
        @author Birger Streckel **/
    static int LoadXML(const std::string& FileName, 
                       uint16* &Img2D, uint16* &ImgDepth, 
                       uint16* &ImgModCoeff,
                       PMDImageMetaData &MetaData2D, 
                       PMDImageMetaData &MetaDataDepth);    
    static int LoadXML(XMLIO &myXML, xmlNodePtr &rootNode, 
                       uint16* &Img2D, uint16* &ImgDepth, 
                       uint16* &ImgModCoeff,
                       PMDImageMetaData &MetaData2D,
                       PMDImageMetaData &MetaDataDepth);

#endif

    /** @brief Returns the bit representation (8 or 16) for the 2D-image in
        the PMD-image filename. 0 if there is no 2D image, -1 in case of 
        error.
        @author Birger Streckel 
    */
    static int GetBitRep(const std::string& FileName);

  protected:
    
    /* set up callback for initialization of new tags*/    
    static void NewTagsInitialize_();
   
    
    /* callback for initialization of new tags*/    
    static void NewTagsCallback_(TIFF *tif);
    
    static int LoadMetaData_(TIFF* tiffimage, 
                             PMDImageMetaData &MetaData);
    
    static int Load2DImage8Bit_(TIFF *tiffimage, uint8* &Img2D,
                                PMDImageMetaData &MetaData2D);
    static int Load2DImage16Bit_(TIFF *tiffimage, uint16* &Img2D, 
                                 PMDImageMetaData &MetaData2D);
    static int LoadDepthImage_(TIFF *tiffimage, uint16* &ImgDepth,
                               PMDImageMetaData &MetaDataDepth);
    static int LoadModCoeffImage_(TIFF *tiffimage, uint16* &ImgModCoeff, 
                                PMDImageMetaData MetaDataDepth);

    static void Grey16to8Bit_(uint16* src, uint8* &dst, unsigned int size);
    static uint16 DepthConvert_(float depth);
    static float DepthConvert_(uint16 depth);
    static uint16 ModCoeffConvert_(float modcoeff);
    static float ModCoeffConvert_(uint16 modcoeff);
    
    static int PostprocessData_(uint8* data2d, uint16* dataDepth, 
                                uint16* dataModCoeff,                               
                                Image<unsigned char> &Img2D, 
                                Image<float> &ImgDepth, 
                                Image<float> &ImgModCoeff, 
                                PMDImageMetaData &MetaData2D, 
                                PMDImageMetaData &MetaDataDepth);

  
  
    static uint16 Convert_(float val, float lower, float upper);
    static float Convert_(uint16 val, float lower, float upper);
    

    static int SaveMetaData_(TIFF* tiffimage, 
                              const PMDImageMetaData &MetaData);

    static int Save2DImage8Bit_(TIFF *tiffimage, uint8* Img2D,
                                 PMDImageMetaData MetaData2D,
                                 int LinesPerStrip);
    static int Save2DImage16Bit_(TIFF *tiffimage, uint16* Img2D,
                                  PMDImageMetaData MetaData2D,
                                  int LinesPerStrip);
    static int SaveDepthImage_(TIFF *tiffimage, uint16* ImgDepth, 
                                PMDImageMetaData MetaDataDepth,
                                int LinesPerStrip);
    static int SaveModCoeffImage_(TIFF *tiffimage, uint16* ImgModCoeff, 
                                   PMDImageMetaData MetaDataDepth,
                                   int LinesPerStrip);

    static TIFFExtendProc ParentExtender;
  };
#endif //BIAS_HAVE_TIFF
}
#endif