CObservationStereoImages.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2017, 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 "obs-precomp.h"  // Precompiled headers
 
#include <mrpt/obs/CObservationStereoImages.h>
#include <mrpt/math/CMatrix.h>
#include <mrpt/utils/CStream.h>
#if MRPT_HAS_MATLAB
#include <mexplus/mxarray.h>
#endif
 
using namespace mrpt::obs;
using namespace mrpt::math;
using namespace mrpt::utils;
using namespace mrpt::poses;
 
// This must be added to any CSerializable class implementation file.
IMPLEMENTS_SERIALIZABLE(CObservationStereoImages, CObservation, mrpt::obs)
 
/*---------------------------------------------------------------
                                        Constructor
 ---------------------------------------------------------------*/
CObservationStereoImages::CObservationStereoImages(
        void* iplImageLeft, void* iplImageRight, void* iplImageDisparity,
        bool ownMemory)
        : imageLeft(UNINITIALIZED_IMAGE),
          imageRight(UNINITIALIZED_IMAGE),
          imageDisparity(UNINITIALIZED_IMAGE),
          hasImageDisparity(iplImageDisparity != nullptr),
          hasImageRight(iplImageRight != nullptr)
{
        if (iplImageLeft)
                ownMemory ? imageLeft.setFromIplImage(iplImageLeft)
                                  : imageLeft.loadFromIplImage(iplImageLeft);
        if (iplImageRight)
                ownMemory ? imageRight.setFromIplImage(iplImageRight)
                                  : imageRight.loadFromIplImage(iplImageRight);
        if (iplImageDisparity)
                ownMemory ? imageDisparity.setFromIplImage(iplImageDisparity)
                                  : imageDisparity.loadFromIplImage(iplImageDisparity);
}
 
/*---------------------------------------------------------------
                                        Default Constructor
 ---------------------------------------------------------------*/
CObservationStereoImages::CObservationStereoImages()
        : hasImageDisparity(false), hasImageRight(true)
{
}
 
/*---------------------------------------------------------------
                                        Destructor
 ---------------------------------------------------------------*/
CObservationStereoImages::~CObservationStereoImages() {}
/*---------------------------------------------------------------
  Implements the writing to a CStream capability of CSerializable objects
 ---------------------------------------------------------------*/
void CObservationStereoImages::writeToStream(
        mrpt::utils::CStream& out, int* version) const
{
        if (version)
                *version = 6;
        else
        {
                // The data
                out << cameraPose << leftCamera << rightCamera << imageLeft;
 
                out << hasImageDisparity << hasImageRight;
 
                if (hasImageRight) out << imageRight;
 
                if (hasImageDisparity) out << imageDisparity;
 
                out << timestamp;
                out << rightCameraPose;
                out << sensorLabel;
        }
}
 
/*---------------------------------------------------------------
  Implements the reading from a CStream capability of CSerializable objects
 ---------------------------------------------------------------*/
void CObservationStereoImages::readFromStream(
        mrpt::utils::CStream& in, int version)
{
        switch (version)
        {
                case 6:
                {
                        in >> cameraPose >> leftCamera >> rightCamera >> imageLeft;
 
                        in >> hasImageDisparity >> hasImageRight;
 
                        if (hasImageRight) in >> imageRight;
 
                        if (hasImageDisparity) in >> imageDisparity;
 
                        in >> timestamp;
                        in >> rightCameraPose;
                        in >> sensorLabel;
                }
                break;
 
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                {
                        // This, for backwards compatibility before version 6:
                        hasImageRight = true;
                        hasImageDisparity = false;
 
                        if (version < 5)
                        {
                                CPose3D aux;
                                in >> aux;
                                cameraPose = CPose3DQuat(aux);
                        }
 
                        if (version >= 5)
                        {
                                in >> cameraPose >> leftCamera >> rightCamera;
                        }
                        else
                        {
                                CMatrix intParams;
                                in >> intParams;  // Get the intrinsic params
                                leftCamera.intrinsicParams =
                                        CMatrixDouble33(intParams);  // Set them to both cameras
                                rightCamera.intrinsicParams = CMatrixDouble33(
                                        intParams);  // ... distortion parameters are set to zero
                        }
 
                        in >> imageLeft >> imageRight;  // For all the versions
 
                        if (version >= 1)
                                in >> timestamp;
                        else
                                timestamp = INVALID_TIMESTAMP;  // For version 1 to 5
                        if (version >= 2)
                        {
                                if (version < 5)
                                {
                                        CPose3D aux;
                                        in >> aux;
                                        rightCameraPose = CPose3DQuat(aux);
                                }
                                else
                                        in >> rightCameraPose;
                        }
                        else
                                rightCameraPose = CPose3DQuat(
                                        0.10f, 0, 0, mrpt::math::CQuaternionDouble(
                                                                         1, 0, 0, 0));  // For version 1 to 5
 
                        if (version >= 3 && version < 5)  // For versions 3 & 4
                        {
                                double foc;
                                in >> foc;  // Get the focal length in meters
                                leftCamera.focalLengthMeters = rightCamera.focalLengthMeters =
                                        foc;  // ... and set it to both cameras
                        }
                        else if (version < 3)
                                leftCamera.focalLengthMeters = rightCamera.focalLengthMeters =
                                        0.002;  // For version 0, 1 & 2 (from version 5, this
                        // parameter is included in the TCamera objects)
 
                        if (version >= 4)
                                in >> sensorLabel;
                        else
                                sensorLabel = "";  // For version 1 to 5
                }
                break;
                default:
                        MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
        };
}
 
/*---------------------------------------------------------------
  Implements the writing to a mxArray for Matlab
 ---------------------------------------------------------------*/
#if MRPT_HAS_MATLAB
// Add to implement mexplus::from template specialization
IMPLEMENTS_MEXPLUS_FROM(mrpt::obs::CObservationStereoImages)
 
mxArray* CObservationStereoImages::writeToMatlab() const
{
        const char* fields[] = {"class",   "ts",         "sensorLabel", "imageL",
                                                        "imageR",  "poseL",  "poseLR",          "poseR",
                                                        "paramsL", "paramsR"};
        mexplus::MxArray obs_struct(
                mexplus::MxArray::Struct(sizeof(fields) / sizeof(fields[0]), fields));
 
        obs_struct.set("class", this->GetRuntimeClass()->className);
        obs_struct.set("ts", this->timestamp);
        obs_struct.set("sensorLabel", this->sensorLabel);
        obs_struct.set("imageL", this->imageLeft);
        obs_struct.set("imageR", this->imageRight);
        obs_struct.set("poseL", this->cameraPose);
        obs_struct.set("poseR", this->cameraPose + this->rightCameraPose);
        obs_struct.set("poseLR", this->rightCameraPose);
        obs_struct.set("paramsL", this->leftCamera);
        obs_struct.set("paramsR", this->rightCamera);
        return obs_struct.release();
}
#endif
 
/** Populates a TStereoCamera structure with the parameters in \a leftCamera, \a
 * rightCamera and \a rightCameraPose */
void CObservationStereoImages::getStereoCameraParams(
        mrpt::utils::TStereoCamera& out_params) const
{
        out_params.leftCamera = this->leftCamera;
        out_params.rightCamera = this->rightCamera;
        out_params.rightCameraPose = this->rightCameraPose;
}
 
/** Sets \a leftCamera, \a rightCamera and \a rightCameraPose from a
 * TStereoCamera structure */
void CObservationStereoImages::setStereoCameraParams(
        const mrpt::utils::TStereoCamera& in_params)
{
        this->leftCamera = in_params.leftCamera;
        this->rightCamera = in_params.rightCamera;
        this->rightCameraPose = in_params.rightCameraPose;
}
 
/** This method only checks whether ALL the distortion parameters in \a
 * leftCamera are set to zero, which is
  * the convention in MRPT to denote that this pair of stereo images has been
 * rectified.
  */
bool CObservationStereoImages::areImagesRectified() const
{
        return (leftCamera.dist.array() == 0).all();
}
 
// Do an efficient swap of all data members of this object with "o".
void CObservationStereoImages::swap(CObservationStereoImages& o)
{
        CObservation::swap(o);
 
        imageLeft.swap(o.imageLeft);
        imageRight.swap(o.imageRight);
        imageDisparity.swap(o.imageDisparity);
 
        std::swap(hasImageDisparity, o.hasImageDisparity);
        std::swap(hasImageRight, o.hasImageRight);
 
        std::swap(leftCamera, o.leftCamera);
        std::swap(rightCamera, o.rightCamera);
 
        std::swap(cameraPose, o.cameraPose);
        std::swap(rightCameraPose, o.rightCameraPose);
}
 
void CObservationStereoImages::getDescriptionAsText(std::ostream& o) const
{
        using namespace std;
        CObservation::getDescriptionAsText(o);
 
        o << "Homogeneous matrix for the sensor's 3D pose, relative to robot "
                 "base:\n";
        o << cameraPose.getHomogeneousMatrixVal() << endl
          << "Camera pose: " << cameraPose << endl
          << "Camera pose (YPR): " << CPose3D(cameraPose) << endl
          << endl;
 
        mrpt::utils::TStereoCamera stParams;
        getStereoCameraParams(stParams);
        o << stParams.dumpAsText() << endl;
 
        o << "Right camera pose wrt left camera (YPR):" << endl
          << CPose3D(stParams.rightCameraPose) << endl;
 
        if (imageLeft.isExternallyStored())
                o << " Left image is stored externally in file: "
                  << imageLeft.getExternalStorageFile() << endl;
 
        o << " Right image";
        if (hasImageRight)
        {
                if (imageRight.isExternallyStored())
                        o << " is stored externally in file: "
                          << imageRight.getExternalStorageFile() << endl;
        }
        else
                o << " : No.\n";
 
        o << " Disparity image";
        if (hasImageDisparity)
        {
                if (imageDisparity.isExternallyStored())
                        o << " is stored externally in file: "
                          << imageDisparity.getExternalStorageFile() << endl;
        }
        else
                o << " : No.\n";
 
        o << format(
                " Image size: %ux%u pixels\n", (unsigned int)imageLeft.getWidth(),
                (unsigned int)imageLeft.getHeight());
 
        o << " Channels order: " << imageLeft.getChannelsOrder() << endl;
 
        o << format(
                " Rows are stored in top-bottom order: %s\n",
                imageLeft.isOriginTopLeft() ? "YES" : "NO");
}