CStereoRectifyMap.h

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 |
   +------------------------------------------------------------------------+ */
#ifndef mrpt_CStereoRectifyMap_H
#define mrpt_CStereoRectifyMap_H
 
#include <mrpt/img/TStereoCamera.h>
#include <mrpt/img/CImage.h>
#include <mrpt/obs/CObservationStereoImages.h>
#include <mrpt/poses/CPose3DQuat.h>
 
namespace mrpt::vision
{
/** Use this class to rectify stereo images if the same distortion maps are
 * reused over and over again.
  *  The rectify maps are cached internally and only computed once for the
 * camera parameters.
  * The stereo camera calibration must be supplied in a
 * mrpt::util::TStereoCamera structure
  *  (which provides method for loading from a plain text config file) or
 * directly from the
  *  parameters of a mrpt::obs::CObservationStereoImages object.
  *
  * Remember that the rectified images have a different set of intrinsic
 * parameters than the
  *  original images, which can be retrieved with \a getRectifiedImageParams()
  *
  *  Works with grayscale or color images.
  *
  *  Refer to the program stereo-calib-gui for a tool that generates the
 * required stereo camera parameters
  *  from a set of stereo images of a checkerboard.
  *
  *  Example of usage with mrpt::obs::CObservationStereoImages:
  *
  * \code
  *   CStereoRectifyMap   rectify_map;
  *   // Set options as desired:
  *   // rectify_map.setAlpha(...);
  *   // rectify_map.enableBothCentersCoincide(...);
  *
  *   while (true) {
  *     mrpt::obs::CObservationStereoImages::Ptr obs_stereo = ... // Grab stereo
 * observation from wherever
  *
  *     // Only once, construct the rectification maps:
  *     if (!rectify_map.isSet())
  *       rectify_map.setFromCamParams(*obs_stereo);
  *
  *     // Rectify in place:
  *     unmap.rectify(*obs_stereo);
  *     // Rectified images are now in: obs_stereo->imageLeft &
 * obs_stereo->imageRight
  *   }
  * \endcode
  *
  *  Read also the tutorial page online:
 * http://www.mrpt.org/Rectifying_stereo_images
  *
  * \sa CUndistortMap, mrpt::obs::CObservationStereoImages,
 * mrpt::img::TCamera, the application <a
 * href="http://www.mrpt.org/Application:camera-calib" >camera-calib</a> for
 * calibrating a camera.
  *
  * \note This class provides a uniform wrap over different OpenCV versions. The
 * "alpha" parameter is ignored if built against OpenCV 2.0.X
  *
  * \ingroup mrpt_vision_grp
  */
class CStereoRectifyMap
{
   public:
    /** Default ctor */
    CStereoRectifyMap();
 
    /** @name Rectify map preparation and setting/getting of parameters
        @{ */
    /** Returns true if \a setFromCamParams() has been already called, false
     * otherwise.
      *  Can be used within loops to determine the first usage of the object and
     * when it needs to be initialized.
      */
    inline bool isSet() const { return !m_dat_mapx_left.empty(); }
    /** Prepares the mapping from the intrinsic, distortion and relative pose
     * parameters of a stereo camera.
      * Must be called before invoking \a rectify().
      * The \a alpha parameter can be changed with \a setAlpha() before invoking
     * this method; otherwise, the current rectification maps will be marked as
     * invalid and should be prepared again.
      * \sa setAlpha()
      */
    void setFromCamParams(const mrpt::img::TStereoCamera& params);
 
    /** A wrapper to \a setFromCamParams() which takes the parameters from an
     * stereo observation object */
    void setFromCamParams(const mrpt::obs::CObservationStereoImages& stereo_obs)
    {
        mrpt::img::TStereoCamera params;
        stereo_obs.getStereoCameraParams(params);
        setFromCamParams(params);
    }
 
    /** Returns the camera parameters which were used to generate the distortion
     * map, as passed by the user to \a setFromCamParams */
    inline const mrpt::img::TStereoCamera& getCameraParams() const
    {
        return m_camera_params;
    }
 
    /** After computing the rectification maps, this method retrieves the
     * calibration parameters of the rectified images
      *  (which won't have any distortion).
      * \exception std::exception If the rectification maps have not been
     * computed.
      */
    const mrpt::img::TStereoCamera& getRectifiedImageParams() const;
 
    /** Just like \a getRectifiedImageParams() but for the left camera only */
    const mrpt::img::TCamera& getRectifiedLeftImageParams() const;
    /** Just like \a getRectifiedImageParams() but for the right camera only */
    const mrpt::img::TCamera& getRectifiedRightImageParams() const;
 
    /** Sets the \a alpha parameter which controls the zoom in/out of the
     * rectified images, such that:
      *  - alpha=0 => rectified images are zoom in so that only valid pixels are
     * visible
      *  - alpha=1 => rectified images will contain large "black areas" but no
     * pixel from the original image will be lost.
      * Intermediary values leads to intermediary results.
      * Its default value (-1) means auto guess by the OpenCV's algorithm.
      * \note Call this method before building the rectification maps, otherwise
     * they'll be marked as invalid.
      */
    void setAlpha(double alpha);
 
    /** Return the \a alpha parameter \sa setAlpha */
    inline double getAlpha() const { return m_alpha; }
    /** If enabled, the computed maps will rectify images to a size different
     * than their original size.
      * \note Call this method before building the rectification maps, otherwise
     * they'll be marked as invalid.
      */
    void enableResizeOutput(
        bool enable, unsigned int target_width = 0,
        unsigned int target_height = 0);
 
    /** Returns whether resizing is enabled (default=false) \sa
     * enableResizeOutput */
    bool isEnabledResizeOutput() const { return m_resize_output; }
    /** Only when \a isEnabledResizeOutput() returns true, this gets the target
     * size  \sa enableResizeOutput */
    mrpt::img::TImageSize getResizeOutputSize() const
    {
        return m_resize_output_value;
    }
 
    /** Change remap interpolation method (default=Lineal). This parameter can
     * be safely changed at any instant without consequences. */
    void setInterpolationMethod(const mrpt::img::TInterpolationMethod interp)
    {
        m_interpolation_method = interp;
    }
 
    /** Get the currently selected interpolation method \sa
     * setInterpolationMethod */
    mrpt::img::TInterpolationMethod getInterpolationMethod() const
    {
        return m_interpolation_method;
    }
 
    /** If enabled (default=false), the principal points in both output images
     * will coincide.
      * \note Call this method before building the rectification maps, otherwise
     * they'll be marked as invalid.
      */
    void enableBothCentersCoincide(bool enable = true);
 
    /** \sa enableBothCentersCoincide */
    bool isEnabledBothCentersCoincide() const
    {
        return m_enable_both_centers_coincide;
    }
 
    /** After computing the rectification maps, get the rotation applied to the
      * left/right camera so their virtual image plane is the same after
     * rectification */
    const mrpt::poses::CPose3DQuat& getLeftCameraRot() const
    {
        return m_rot_left;
    }
    /** See \a getLeftCameraRot()  */
    const mrpt::poses::CPose3DQuat& getRightCameraRot() const
    {
        return m_rot_right;
    }
    /** Direct input access to rectify maps */
    void setRectifyMaps(
        const std::vector<int16_t>& left_x, const std::vector<uint16_t>& left_y,
        const std::vector<int16_t>& right_x,
        const std::vector<uint16_t>& right_y);
 
    /** Direct input access to rectify maps. This method swaps the vectors so
     * the inputs are no longer available.*/
    void setRectifyMapsFast(
        std::vector<int16_t>& left_x, std::vector<uint16_t>& left_y,
        std::vector<int16_t>& right_x, std::vector<uint16_t>& right_y);
 
    /** @} */
 
    /** @name Rectify methods
        @{ */
 
    /** Rectify the input image pair and save the result in a different output
     * images - \a setFromCamParams() must have been set prior to calling this.
      * The previous contents of the output images are completely ignored, but
     * if they are already of the
      * correct size and type, allocation time will be saved.
      * Recall that \a getRectifiedImageParams() provides you the new intrinsic
     * parameters of these images.
      * \exception std::exception If the rectification maps have not been
     * computed.
      * \note The same image CANNOT be at the same time input and output, in
     * which case an exception will be raised (but see the overloaded version
     * for in-place rectification)
      */
    void rectify(
        const mrpt::img::CImage& in_left_image,
        const mrpt::img::CImage& in_right_image,
        mrpt::img::CImage& out_left_image,
        mrpt::img::CImage& out_right_image) const;
 
    /** Overloaded version for in-place rectification: replace input images with
     * their rectified versions
      * If \a use_internal_mem_cache is set to \a true (recommended), will reuse
     * over and over again the same
      * auxiliary images (kept internally to this object) needed for in-place
     * rectification.
      * The only reason not to enable this cache is when multiple threads can
     * invoke this method simultaneously.
      */
    void rectify(
        mrpt::img::CImage& left_image, mrpt::img::CImage& right_image,
        const bool use_internal_mem_cache = true) const;
 
    /** Overloaded version for in-place rectification of image pairs stored in a
     * mrpt::obs::CObservationStereoImages.
      *  Upon return, the new camera intrinsic parameters will be already stored
     * in the observation object.
      * If \a use_internal_mem_cache is set to \a true (recommended), will reuse
     * over and over again the same
      * auxiliary images (kept internally to this object) needed for in-place
     * rectification.
      * The only reason not to enable this cache is when multiple threads can
     * invoke this method simultaneously.
      * \note This method uses the left & right camera rotations computed by the
     * rectification map to update
      *         mrpt::obs::CObservationStereoImages::cameraPose (left camera wrt
     * the robot frame) and
      *         mrpt::obs::CObservationStereoImages::rightCameraPose (right wrt
     * left camera).
      */
    void rectify(
        mrpt::obs::CObservationStereoImages& stereo_image_observation,
        const bool use_internal_mem_cache = true) const;
 
    /** Just like rectify() but directly works with OpenCV's "IplImage*", which
     * must be passed as "void*" to avoid header dependencies
      *  Output images CANNOT coincide with the input images. */
    void rectify_IPL(
        const void* in_left_image, const void* in_right_image,
        void* out_left_image, void* out_right_image) const;
 
    /** @} */
 
   private:
    double m_alpha;
    bool m_resize_output;
    bool m_enable_both_centers_coincide;
    mrpt::img::TImageSize m_resize_output_value;
    mrpt::img::TInterpolationMethod m_interpolation_method;
 
    /** Memory caches for in-place rectification speed-up. */
    mutable mrpt::img::CImage m_cache1, m_cache2;
 
    std::vector<int16_t> m_dat_mapx_left, m_dat_mapx_right;
    std::vector<uint16_t> m_dat_mapy_left, m_dat_mapy_right;
 
    /** A copy of the data provided by the user */
    mrpt::img::TStereoCamera m_camera_params;
    /** Resulting images params */
    mrpt::img::TStereoCamera m_rectified_image_params;
 
    /** The rotation applied to the left/right camera so their virtual image
     * plane is the same after rectification. */
    mrpt::poses::CPose3DQuat m_rot_left, m_rot_right;
 
    void internal_invalidate();
 
};  // end class
 
}
#endif