VideoSource_PMD.hh

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

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


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

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

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

#ifndef __BIASVIDEOSOURCE_PMD_HH__
#define __BIASVIDEOSOURCE_PMD_HH__

#include <bias_config.h>

#include <VideoSource/VideoSource_Base.hh>
#include <Image/Camera.hh>
#include <vector>
#include <pmdsdk2.h>

namespace BIAS
{

  enum EXPOSURE_MODE
  {
    NORMAL, SMB
  };

  /**
   @class VideoSource_PMD
   @ingroup g_videosource
   @brief Support for CamCube usb cam
   @author fkellner 03/09 
  */
  class BIASVideoSource_EXPORT VideoSource_PMD : public VideoSource
  {

  public:
    VideoSource_PMD();
    virtual ~VideoSource_PMD();

    //try to open first unused PMD-camera
    virtual int OpenDevice();
    //try to open a specific camera-device
    virtual int OpenDevice(int camNr);
    //try to open a specific camera-device
    virtual int OpenDevice(std::string serialNumber);
    //close an active camera
    virtual int CloseDevice();
    /** \brief only set the plugin to be opened at OpenDevice */
    void SetProcessingPlugin(std::string plugin);
    /** \brief Open the processing plugin */
    int OpenProcessingPlugin(std::string plugin=BIAS_PMD_PMDTec_PROCPLUGIN);
    /** \brief Close the processing plugin */
    int CloseProcessingPlugin();

    /** \brief only set the plugin to be opened at OpenDevice */
    void SetSourcePlugin(std::string plugin);
    /** \brief Open the source plugin */
    int OpenSourcePlugin(std::string serial,std::string plugin=BIAS_PMD_PMDTec_SOURCEPLUGIN);
    
    //no needed for now
    virtual int PreGrab();
    virtual int PostGrab();

    bool IsSourcePluginOpen();
    bool IsProcessingPluginOpen();

    /** 
     Returns current framerate
     */
    double GetFPS()
    {
      BIASERR("Not Supported");
      return 0.0;
    }

    virtual int InitImage(ImageBase &img)
    {
      return InitImage_(img, ImageBase::ST_unsignedchar, ImageBase::CM_Grey);
    }
    virtual int InitDepthImage(ImageBase &img)
    {
      return InitImage_(img, ImageBase::ST_float, ImageBase::CM_Depth);
    }
    virtual int InitIntensityImage(ImageBase &img)
    {
      return InitImage_(img, ImageBase::ST_float, ImageBase::CM_Grey);
    }
    virtual int InitModCoeffImage(ImageBase &img)
    {
      return InitImage_(img, ImageBase::ST_float, ImageBase::CM_Grey);
    }
    
    void GrabImageReturnsDepth(bool on) {
      bGrabImageReturnsDepth_ = on;
    }
    
    /** Returns the 2D image, and reads depth and modulation coefficients */
    virtual int GrabSingle(Camera<unsigned char> &image);

    int GrabSourceData(char* sourceData, unsigned int size);
    int GrabSourceData(BIAS::Image<char>& sourceData);
    int CalcDistancesFromSourceData(BIAS::Image<char>& sourceData,
            BIAS::Image<float>& depthImage);
    int CalcIntensitiesFromSourceData(BIAS::Image<char>& sourceData,
            BIAS::Image<float>& intImage);
    int CalcAmplitudesFromSourceData(BIAS::Image<char>& sourceData,
            BIAS::Image<float>& ampImage);

    int CalcDistancesFromSourceData(char* sourceData, PMDDataDescription dd,
            BIAS::Image<float>& depthImage);

    int CalcIntensitiesFromSourceData(char* sourceData, PMDDataDescription dd,
                BIAS::Image<float>& intImage);

    int CalcAmplitudesFromSourceData(char* sourceData, PMDDataDescription dd,
            BIAS::Image<float>& ampImage);

    /**
       \brief Set IntegrationTime
       \param inttime[in]: integration time in microseconds
       \return 0 on sucess, < 0 otherwise;
     */
    virtual int SetIntegrationTime(const unsigned int inttime);

    /**
       \brief Set IntegrationTime
       \param inttime[in]: integration time in milliseconds
       \return 0 on sucess, < 0 otherwise;
     */
    virtual int SetIntegrationTimeMS(const unsigned int inttime);

    /**
       \brief Get the IntegrationTime
       \param val[out]: integration time in microseconds
       \return 0;
     */
    virtual int GetIntegrationTime(unsigned int &val);

    /**
       \brief Get the IntegrationTime in milliseconds
       \param val[out]: integration time in milliseconds
       \return 0;
    */
    virtual int GetIntegrationTimeMS(unsigned int &val);

    PMDDataDescription& GetDataDescription();

    int SetExposureMode(EXPOSURE_MODE mode);
    EXPOSURE_MODE GetExposureMode();
    
    /* Set the Modulation frequency */
    int SetModulationFrequency(const unsigned int dModulationFrequency);

    /* Get the Modulation frequency*/
    int GetModulationFrequency(unsigned int &val);

    /* Set Distance Offset */
    int SetDistanceOffset(const unsigned int in_millimeters);

    /* Get Distance Offset */
    int GetDistanceOffset(unsigned int &millimeters);

    /** Returns the depth image. Must be called after GrabSingle() */
    int GrabSingleDepth(Camera<float> &image);

    /** Returns the amplitude image. Must be called after GrabSingle() */
    int GrabSingleModCoeff(Camera<float> &image);

    /** Returns the amplitude image. Must be called after GrabSingle() */
    int GrabSingleIntensity(Camera<float> &image);

    void SetGenerateNewUIDs(bool s);
    void EnsureLatestFrame(const bool ensure);

    int SetROI(const unsigned int UpperLeftX, const unsigned int UpperLeftY,
        const unsigned int Width, const unsigned int Height);
    int SetFOV(const float fov);

    int GetSerialNumber(std::string &serial);

    int SetFPNCalibrationOn(bool on);

    int GetSourceDataSize();

  protected:
    int InitImage_(ImageBase &img, ImageBase::EStorageType st,
                   ImageBase::EColorModel cm);
    void InitAllImages_();

    void SetMaxDist_();

    void FlopImage_(float *src, float *dst);

    bool bEnsureLatestFrame_;
    unsigned int integrationTime_;
    unsigned int distanceOffset_;
    unsigned int modulationFrequency_;

    bool bIsOpen_;
    bool procPluginIsOpen_;
    bool sourcePluginIsOpen_;

    std::string procPluginPath_;
    std::string sourcePluginPath_;

    //MIP images, holding grabbed data
    BIAS::Camera<unsigned char> DepthImg_;
    BIAS::Camera<unsigned char> IntensityImg_;
    BIAS::Camera<float> tmpImg_, tmpScale_;
    BIAS::Camera<float> DepthImgF_;
    BIAS::Camera<float> ModCoeffImgF_;
    BIAS::Camera<float> IntensityImgF_;

    float *idaDIF_, *idaMCIF_, *idaIIF_, *idaTmp_;
    unsigned char *idaDI_, *idaII_;

    PMDHandle handle_;
    PMDDataDescription datadesc_;

    EXPOSURE_MODE expMode_;

    float max_dist_;
    size_t bufSz_;
    bool bGrabImageReturnsDepth_;
    std::string serialNumber_;
  };

}

#endif //__VIDEOSOURCE_PMD_HH__