VideoSource_SwissRanger.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_SWISSRANGER_HH__
#define __BIASVIDEOSOURCE_SWISSRANGER_HH__

#include <VideoSource/VideoSource_Base.hh>
#include <Image/Camera.hh>
#include <bias_config.h>
#include <vector>
#include <Base/Common/W32Compat.hh>

//this is needed because DWORD is used in header
typedef unsigned long DWORD;

#include <libMesaSR.h>

namespace BIAS {

  /** @class VideoSource_SwissRanger
      @ingroup g_videosource
      @brief Support for SwissRanger usb cam
      @author fkellner 10/2007 */
  class BIASVideoSource_EXPORT VideoSource_SwissRanger : public VideoSource {

  public:
    VideoSource_SwissRanger();
    ~VideoSource_SwissRanger();

    /** \brief try to open first unused PMD-camera
        \return 0 on success, -1 of opening failed, -2 if opening
                failed because of wrong image width */
    virtual int OpenDevice();
    /** \brief try to open a specific camera-device
        \return 0 on success,  -1 of opening failed, -2 if opening
                failed because of wrong image width */
    virtual int OpenDevice(int camNr);
    /** \brief close an active camera */
    virtual int CloseDevice();

    /** \brief no needed for PreGrab now, does not do anything */
    virtual int PreGrab();
    /** \brief no needed for PostGrab now, does not do anything */
    virtual int PostGrab();

    /** \brief Dummy function, does not do anything*/
    virtual int GetCapabilities(VideoSourceCapabilities &caps);
    /** \brief Dummy function, does not do anything*/
    virtual int GetCapabilities(const char *device, VideoSourceCapabilities &caps);

    /** \brief Returns current framerate */
    double GetFPS();

    /** \brief Init the grey image to grab to*/
    virtual int InitImage(ImageBase &img);
    /** \brief Init the depth image to grab to*/
    virtual int InitDepthImage(ImageBase &img);

    /** Returns the 2D image, and reads depth and modulation coefficients */
    virtual int GrabSingle(Camera<unsigned char> &image);

    /** \brief Set IntegrationTime (as uchar 0-255)*/
    virtual int SetIntegrationTime(const unsigned char inttime);

    /** \brief Get IntegrationTime (as uchar 0-255)*/
    virtual int GetIntegrationTime(unsigned char &val) {
      val = integrationTime_;
      return 0;
    }
    
    /** \brief Set IntegrationTime in ms (gets clipped to min/max for camera)*/
    virtual int SetIntegrationTimeMS(float inttime);

    /** \brief Get IntegrationTime in ms*/
    virtual int GetIntegrationTimeMS(float &inttime);

    /** \brief Set the Modulation frequency (from defines.h)
                 MF_40MHz=0, //!<SR3k: maximal range 3.75m
                 MF_30MHz=1,   //!<SR3k, SR4k: maximal range 5m
                 MF_21MHz=2,   //!<SR3k: maximal range 7.14m
                 MF_20MHz=3,   //!<SR3k: maximal range 7.5m
                 MF_19MHz=4,   //!<SR3k: maximal range 7.89m
                 MF_60MHz=5,   //!<SR4k: maximal range 2.5m \intDoc{frequency}
                 MF_15MHz=6,   //!<SR4k: maximal range 10m \intDoc{frequency}
                 MF_10MHz=7,   //!<SR4k: maximal range 15m \intDoc{frequency}
                 MF_29MHz=8,   //!<SR4k: maximal range 5.17m
                 MF_31MHz=9,   //!<SR4k: maximal range 4.84m
                 MF_LAST=10};
        */
    int SetModulationFrequency(ModulationFrq dModulationFrequency);

    /** \brief Get the Modulation frequency*/
    int GetModulationFrequency(unsigned int &val) {
      val = modulationFrequency_;
      return 0;
    }

    /** \brief Set Amplitude Threshold */
    int SetAmplitudeThreshold(const unsigned short val) {
      amplitudeThreshold_ = val;
      return SR_SetAmplitudeThreshold(srCam_, amplitudeThreshold_);
    }

    /** \brief Get Amplitude Threshold */
    inline int GetAmplitudeThreshold(unsigned short &val) {
      val = amplitudeThreshold_;
      return 0;
    }

    /** \brief Set Saturation Threshold */
    int SetSaturationThreshold(const unsigned short val) {
      saturationThreshold_ = val;
      return SR_SetAmplitudeThreshold(srCam_, saturationThreshold_);
    }

    /** \brief Get Saturation Threshold */
    inline int GetSaturationThreshold(unsigned short &val) {
      val = saturationThreshold_;
      return 0;
    }

    /** \briefSet Distance Offset */
    int SetDistanceOffset(const unsigned short val) {
      distanceOffset_ = val;
      return SR_SetDistanceOffset(srCam_, distanceOffset_);
    }

    /** \brief Get Distance Offset */
    int GetDistanceOffset(unsigned short &val) {
      val = distanceOffset_;
      return 0;
    }

    /** \brief Returns the depth image. Must be called after GrabSingle() */
    inline int GrabSingleDepth(Camera<float> &image)
    { 
      if (!DepthImgF_.IsEmpty()) {
        image = DepthImgF_; 
        return 0;
      } 
      return -1;
    }

    /** \brief Returns the amplitude image. Must be called after GrabSingle() */
    inline int GrabSingleModCoeff(Camera<float> &image)
    {       
      if (!ModCoeffImg_.IsEmpty()) {
        image = ModCoeffImg_; 
        return 0;
      } 
      return -1;
    }
    /** \brief Sets whether to generate new UIDS for each image */
    void SetGenerateNewUIDs(bool s) {  
      BIASWARNONCE("Always generating new UUIDS for Swissranger images.");
    }
    
    /** \brief Sets the autoillumination default settings on or off*/
    inline int SetAutoIllumination(const bool on) {
      if (on)
        return SetAutoIllumination(5, 255, 10, 45);
      else
        return SetAutoIllumination(0xff, 0, 0, 0);
    }
    
    /** \brief Sets the autoillumination settings */
    inline int SetAutoIllumination(const unsigned char minIntTime, 
                                   const unsigned char maxIntTime,
                                   const unsigned char percentOverPos, 
                                   const unsigned char desiredPos) {
      return SR_SetAutoExposure(srCam_, minIntTime, maxIntTime,
                                percentOverPos, desiredPos);
    }
    
    //    /** \brief Sets the scattering filter */
        //    inline int SetScatteringFilter(const unsigned char blkSzX,
        //                                   const unsigned char blkSzY) {
        //      return SR_SetScatteringFilter(srCam_, blkSzX, blkSzY);
        //    }
    
    /** \brief Ensure latest frame calls grab twice to really get
     * current image instead of buffered image.*/
    void EnsureLatestFrame(const bool ensure) {
      bEnsureLatestFrame_ = ensure;
    }
    /** \brief Sets whether a call to GrabSingle should return the depth image */
    void GrabImageReturnsDepth(bool on) {
      bGrabImageReturnsDepth_ = on;
    }
    
    /** \brief returns the version of the used software */
    int GetSoftwareVersion(std::string& version);

    /** \brief returns the device string of the camera */
    int GetDeviceString(std::string& device);


  protected:
    void ConvertImageFloatToCharNormalized_(const Image<float> src, Image<unsigned char> &dst, bool useMaxDist=false);
    void ConvertRawImageToFloat_(const unsigned short* data, Image<float> &dst);
    void ConvertRawImage_(const unsigned short* data, Image<float> &dst);

    void SetMaxDist_();
    
    /// uses libusb directly to reset the device in case of failure on open
    void ResetUsbDeviceConnection_();
    
    bool bEnsureLatestFrame_;
    unsigned short amplitudeThreshold_;
    unsigned short saturationThreshold_;
    unsigned char integrationTime_;
    unsigned short distanceOffset_;
    ModulationFrq modulationFrequency_;

    // bIsOpen_ indicates successful OpenDevice, 
    // bRetryOpen_ will be set false after first try so OpenDevice fails if it has to try more than twice
    bool bIsOpen_, bRetryOpen_;

    //MIP images, holding grabbed data
    BIAS::Camera<unsigned char> DepthImg_;
    BIAS::Camera<float> DepthImgF_;
    BIAS::Camera<float> ModCoeffImg_;

    CMesaDevice* srCam_;

    ImgEntry *  imgEntryArray; 

    const unsigned short* dataDepth_;
    const unsigned short* dataAmp_;
    float* modcoeff_;
    unsigned int serialNumber_;
    float max_dist_;
    bool bGrabImageReturnsDepth_;
    //size_t bufSz_;
    CamType camType_;
  };

}

#endif //__VIDEOSOURCE_SWISSRANGER_HH__