CStereoGrabber_SVS.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "hwdrivers-precomp.h"  // Precompiled headers
 
#include <mrpt/hwdrivers/CStereoGrabber_SVS.h>
 
// Universal include for all versions of OpenCV
#include <mrpt/otherlibs/do_opencv_includes.h>
 
#if MRPT_HAS_SVS
#include <svsclass.h>
#include <dcs.h>
#endif
 
using namespace std;
using namespace mrpt;
using namespace mrpt::obs;
using namespace mrpt::hwdrivers;
 
/*-------------------------------------------------------------
                                        Constructor
 -------------------------------------------------------------*/
CStereoGrabber_SVS::CStereoGrabber_SVS(
        int cameraIndex, const TCaptureOptions_SVS& options)
        : m_bInitialized(false),
          m_videoObject(nullptr),
          m_stereoImage(nullptr),
          m_disparityParams(nullptr),
          m_resolutionX(options.frame_width),
          m_resolutionY(options.frame_height),
          m_procesOnChip(options.m_procesOnChip),
          m_calDisparity(options.m_calDisparity),
          m_options(options)
{
#if MRPT_HAS_SVS
 
        // get the svsVideoImages object from the currently loaded camera interface
        m_videoObject = static_cast<svsVideoImages*>(getVideoObject());
        cout << "Using live images:" << endl;
        cout << "svsVideoIdent" << endl;
 
        // Open the stereo device
        bool ret;
        ret = static_cast<svsVideoImages*>(m_videoObject)->Open();
        if (ret)
        {
                cout << " stereo device Opened" << endl;
 
                static_cast<svsVideoImages*>(m_videoObject)
                        ->SetSize(m_resolutionX, m_resolutionY);  // width x height image
 
                m_disparityParams =
                        static_cast<svsVideoImages*>(m_videoObject)->GetDP();
                static_cast<svsVideoImages*>(m_videoObject)
                        ->SetNDisp(m_options.m_NDisp);  // 32 disparities
                static_cast<svsVideoImages*>(m_videoObject)
                        ->SetCorrsize(m_options.m_Corrsize);  // correlation window size
                static_cast<svsVideoImages*>(m_videoObject)
                        ->SetLR(m_options.m_LR);  // no left-right check, not available
                static_cast<svsVideoImages*>(m_videoObject)
                        ->SetThresh(m_options.m_Thresh);  // texture filter
                static_cast<svsVideoImages*>(m_videoObject)
                        ->SetUnique(m_options.m_Unique);  // uniqueness filter
                static_cast<svsVideoImages*>(m_videoObject)
                        ->SetHoropter(m_options.m_Horopter);  // horopter offset
 
                if (!(static_cast<svsVideoImages*>(m_videoObject)
                                  ->SetExposure(0, 0, true, true)))
                {
                        cout << "Can't set Auto exposure" << endl;
                }
                else
                {
                        cout << "Autoexposure set to 0 0" << endl;
                }
 
                /*      videoObject->SetBrightness(true, 0);
                   videoObject->SetAutoExpParams(0.0, -2.0);
           */
                /// videoObject->SetGamma(); search for auto gamma ?
 
                static_cast<svsVideoImages*>(m_videoObject)
                        ->SetRate(m_options.framerate);
                static_cast<svsVideoImages*>(m_videoObject)
                        ->SetSpeckleSize(m_options.m_SpeckleSize);  // TODO add in config
 
                // TODO call CheckParam
                if (static_cast<svsVideoImages*>(m_videoObject)->CheckParams())
                {
                        cout << "Params OK !" << endl;
                        m_initialized = true;
                        m_status = true;
                        bool ret = static_cast<svsVideoImages*>(m_videoObject)->Start();
                        if (ret)
                        {
                                cout << " Start Continuous mode" << endl;
 
                                // NOTE: to do rectification, we have to turn it on...
                                // Here we optionally set up acquisition to rectify the image
 
                                ret =
                                        static_cast<svsVideoImages*>(m_videoObject)->SetRect(true);
                                if (ret)
                                {
                                        cout << "Images will be rectified" << endl;
                                }
                                else
                                {
                                        cout << "Can't set rectification" << endl;
                                }
                                if (m_procesOnChip)
                                {
                                        // NOTE: for STOC device, turn on stereo processing on-chip
                                        if (static_cast<svsVideoImages*>(m_videoObject) &&
                                                static_cast<svsVideoImages*>(m_videoObject)
                                                        ->is_proc_capable)  // can we process on-camera?
                                        {
                                                static_cast<svsVideoImages*>(m_videoObject)
                                                        ->SetProcMode(PROC_MODE_DISPARITY);
                                                cout << "Setting STOC disparity mode" << endl;
                                        }
                                }
                                else
                                {
                                        if (m_processObject)
                                                m_processObject = new svsStereoProcess();
                                        // NOTE: for STOC device, turn off stereo processing on-chip
                                        if (static_cast<svsVideoImages*>(m_videoObject) &&
                                                static_cast<svsVideoImages*>(m_videoObject)
                                                        ->is_proc_capable)  // can we process on-camera?
                                        {
                                                static_cast<svsVideoImages*>(m_videoObject)
                                                        ->SetProcMode(PROC_MODE_OFF);
                                                cout << "Setting STOC stereo mode" << endl;
                                        }
                                }
                        }
                        else
                        {
                                cout << "Can't start continuous capture" << endl;
                                m_status = false;
                        }
                }
                else
                {
                        m_initialized = false;
                        m_status = false;
                        cout << "Params Unconsistents !" << endl;
                }
        }
        else
 
                // TODO essayer de faire un close...
                cout << "Can't open stereo device" << endl;
 
        m_status = false;
 
#else
        MRPT_UNUSED_PARAM(cameraIndex);
        THROW_EXCEPTION("This class requires MRPT built with Videre SVS library.");
#endif
}
 
/*-------------------------------------------------------------
                                        Destructor
 -------------------------------------------------------------*/
CStereoGrabber_SVS::~CStereoGrabber_SVS()
{
#if MRPT_HAS_SVS
        static_cast<svsVideoImages*>(m_videoObject)->Close();
#endif  // No need to raise an exception on "#else" since it's already raised
        // upon construction.
}
 
/*-------------------------------------------------------------
                                        get the image
 -------------------------------------------------------------*/
bool CStereoGrabber_SVS::getStereoObservation(
        mrpt::obs::CObservationStereoImages& out_observation)
{
#if MRPT_HAS_SVS
        if ((m_stereoImage =
                         static_cast<svsVideoImages*>(m_videoObject)->GetImage(500)) &&
                static_cast<svsStereoImage*>(m_stereoImage)->haveImages)  // 500 ms
        // timeout
        // //TODO
        // adjust
        // timeout
        // with
        // framerate
        {
                // get disparity params
                m_disparityParams =
                        static_cast<svsVideoImages*>(m_videoObject)->GetDP();
 
                const size_t sizeOfMat = m_resolutionX * m_resolutionY;
 
                IplImage* ImageLeft = cvCreateImageHeader(
                        cvSize(m_resolutionX, m_resolutionY), IPL_DEPTH_8U, 1);
 
                ImageLeft->widthStep =
                        ImageLeft->width;  // JL: The next line assumes this
                ImageLeft->imageData =
                        (char*)static_cast<svsStereoImage*>(m_stereoImage)->Left();
 
                if (m_procesOnChip)
                {
                        IplImage* ImageDisparity = cvCreateImage(
                                cvSize(m_resolutionX, m_resolutionY), IPL_DEPTH_8U, 1);
 
                        unsigned char* ptrOutDisp;
                        short int* ptrDisp;
 
                        ptrDisp = static_cast<svsStereoImage*>(m_stereoImage)->Disparity();
                        ptrOutDisp = (unsigned char*)ImageDisparity->imageData;
 
                        ASSERT_(
                                ImageDisparity->widthStep ==
                                ImageDisparity->width);  // JL: The code below assumes
                        // image_width == widthStep
 
                        for (int pix = 0; pix < sizeOfMat; pix++, ptrOutDisp++, ptrDisp++)
                        {
                                if (*(ptrDisp) > 0)
                                        *(ptrOutDisp) = (unsigned char)((*(ptrDisp) >> 2) & 0x00FF);
                                else
                                        *(ptrOutDisp) = 0;
                        }
 
                        // Create the object to be return (it will have a fresh timestamp if
                        // it's created now and here):
                        CObservationStereoImages ret_obj(
                                cvCloneImage(ImageLeft),  // Create a new IplImage* which will
                                // be owned by the observation object.
                                nullptr /*has no right*/, ImageDisparity,
                                true /* own the memory, so we don't have to free it here */);
 
                        out_observation.swap(
                                ret_obj);  // Send as output (faster than a "=").
                }
                else if (m_calDisparity)
                {
                        static_cast<svsStereoProcess*>(m_processObject)
                                ->CalcStereo(static_cast<svsStereoImage*>(m_stereoImage));
                        IplImage* ImageDisparity = cvCreateImage(
                                cvSize(m_resolutionX, m_resolutionY), IPL_DEPTH_8U, 1);
 
                        unsigned char* ptrOutDisp;
                        short int* ptrDisp;
 
                        ptrDisp = static_cast<svsStereoImage*>(m_stereoImage)->Disparity();
                        ptrOutDisp = (unsigned char*)ImageDisparity->imageData;
 
                        ASSERT_(
                                ImageDisparity->widthStep ==
                                ImageDisparity->width);  // JL: The code below assumes
                        // image_width == widthStep
 
                        for (int pix = 0; pix < sizeOfMat; pix++, ptrOutDisp++, ptrDisp++)
                        {
                                if (*(ptrDisp) > 0)
                                        *(ptrOutDisp) = (unsigned char)((*(ptrDisp) >> 2) & 0x00FF);
                                else
                                        *(ptrOutDisp) = 0;
                        }
 
                        // Create the object to be return (it will have a fresh timestamp if
                        // it's created now and here):
                        CObservationStereoImages ret_obj(
                                cvCloneImage(ImageLeft),  // Create a new IplImage* which will
                                // be owned by the observation object.
                                nullptr /*has no right*/, ImageDisparity,
                                true /* own the memory, so we don't have to free it here */);
 
                        out_observation.swap(
                                ret_obj);  // Send as output (faster than a "=").
                }
                else
                {
                        IplImage* ImageRight = cvCreateImageHeader(
                                cvSize(m_resolutionX, m_resolutionY), IPL_DEPTH_8U, 1);
                        ImageRight->widthStep =
                                ImageRight->width;  // JL: The next line assumes this
                        ImageRight->imageData =
                                (char*)static_cast<svsStereoImage*>(m_stereoImage)->Right();
 
                        // Create the object to be return (it will have a fresh timestamp if
                        // it's created now and here):
                        CObservationStereoImages ret_obj(
                                cvCloneImage(ImageLeft),  // Create a new IplImage* which will
                                // be owned by the observation object.
                                cvCloneImage(ImageRight), nullptr /*has no disparity*/,
                                true /* own the memory, so we don't have to free it here */);
 
                        out_observation.swap(
                                ret_obj);  // Send as output (faster than a "=").
                }
 
                // cvReleaseImage(&Image Disparity); // No need anymore to release
                // images...
                return true;
        }
 
        return false;
// All ok
#else
        MRPT_UNUSED_PARAM(out_observation);
        // No need to raise an exception on "#else" since it's already raised upon
        // construction.
        return false;  // This shouldn't actually be never reached, just to please
// the compiler.
#endif
}
 
/*-------------------------------------------------------------
                                                TCaptureOptions_bumblebee Constructor
 -------------------------------------------------------------*/
TCaptureOptions_SVS::TCaptureOptions_SVS(
        int _frame_width, int _frame_height, double _framerate, int _NDisp,
        int _Corrsize, int _LR, int _Thresh, int _Unique, int _Horopter,
        int _SpeckleSize, bool _procesOnChip, bool _calDisparity)
{
        frame_width = _frame_width;
        frame_height = _frame_height;
        framerate = _framerate;
        m_NDisp = _NDisp;  // 32 disparities
        m_Corrsize = _Corrsize;  // correlation window size
        m_LR = _LR;  // no left-right check, not available
        m_Thresh = _Thresh;  // texture filter
        m_Unique = _Unique;  // uniqueness filter
        m_Horopter = _Horopter;
        m_SpeckleSize = _SpeckleSize;
        m_procesOnChip = _procesOnChip;
        m_calDisparity = _calDisparity;
}