CGeneralizedEllipsoidTemplate.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 opengl_CGeneralizedEllipsoidTemplate_H
#define opengl_CGeneralizedEllipsoidTemplate_H
 
#include <mrpt/opengl/CRenderizableDisplayList.h>
#include <mrpt/math/CMatrixFixedNumeric.h>
#include <mrpt/math/types_math.h>
#include <mrpt/serialization/CArchive.h>  // for >> ops
#include <mrpt/math/matrix_serialization.h>  // for >> ops
 
namespace mrpt
{
namespace opengl
{
namespace detail
{
template <int DIM>
void renderGeneralizedEllipsoidTemplate(
        const std::vector<mrpt::math::CMatrixFixedNumeric<float, DIM, 1>>& pts,
        const float lineWidth, const uint32_t slices, const uint32_t stacks);
template <>
void renderGeneralizedEllipsoidTemplate<2>(
        const std::vector<mrpt::math::CMatrixFixedNumeric<float, 2, 1>>& pts,
        const float lineWidth, const uint32_t slices, const uint32_t stacks);
template <>
void renderGeneralizedEllipsoidTemplate<3>(
        const std::vector<mrpt::math::CMatrixFixedNumeric<float, 3, 1>>& pts,
        const float lineWidth, const uint32_t slices, const uint32_t stacks);
 
template <int DIM>
void generalizedEllipsoidPoints(
        const mrpt::math::CMatrixFixedNumeric<double, DIM, DIM>& U,
        const mrpt::math::CMatrixFixedNumeric<double, DIM, 1>& mean,
        std::vector<mrpt::math::CMatrixFixedNumeric<float, DIM, 1>>& out_params_pts,
        const uint32_t slices, const uint32_t stacks);
template <>
void generalizedEllipsoidPoints<2>(
        const mrpt::math::CMatrixFixedNumeric<double, 2, 2>& U,
        const mrpt::math::CMatrixFixedNumeric<double, 2, 1>& mean,
        std::vector<mrpt::math::CMatrixFixedNumeric<float, 2, 1>>& out_params_pts,
        const uint32_t slices, const uint32_t stacks);
template <>
void generalizedEllipsoidPoints<3>(
        const mrpt::math::CMatrixFixedNumeric<double, 3, 3>& U,
        const mrpt::math::CMatrixFixedNumeric<double, 3, 1>& mean,
        std::vector<mrpt::math::CMatrixFixedNumeric<float, 3, 1>>& out_params_pts,
        const uint32_t slices, const uint32_t stacks);
}  // namespace detail
 
/** A class that generalizes the concept of an ellipsoid to arbitrary
 * parameterizations of
 *  uncertainty shapes in either 2D or 3D. See derived classes for examples.
 *
 * Please read the documentation of
 * CGeneralizedEllipsoidTemplate::setQuantiles() for learning
 *  the mathematical details about setting the desired confidence interval.
 *
 *  The main method to set the modeled uncertainty is \a setCovMatrixAndMean()
 *
 * \tparam DIM The dimensionality of the parameter space, which must coincide
 * with that of the rendering space (2 or 3)
 *
 * \ingroup mrpt_opengl_grp
 */
template <int DIM>
class CGeneralizedEllipsoidTemplate : public CRenderizableDisplayList
{
   public:
        /** The type of fixed-size covariance matrices for this representation */
        using cov_matrix_t = mrpt::math::CMatrixFixedNumeric<double, DIM, DIM>;
        /** The type of fixed-size vector for this representation */
        using mean_vector_t = mrpt::math::CMatrixFixedNumeric<double, DIM, 1>;
 
        using array_parameter_t = mrpt::math::CMatrixFixedNumeric<float, DIM, 1>;
        using array_point_t = mrpt::math::CMatrixFixedNumeric<float, DIM, 1>;
 
        /**  Set the NxN covariance matrix that will determine the aspect of the
         * ellipsoid - Notice that the
         *  covariance determines the uncertainty in the parameter space, which
         * would be transformed by derived function
         */
        template <typename MATRIX, typename VECTOR>
        void setCovMatrixAndMean(const MATRIX& new_cov, const VECTOR& new_mean)
        {
                MRPT_START
                ASSERT_(new_cov.cols() == new_cov.rows() && new_cov.cols() == DIM);
                m_cov = new_cov;
                m_mean = new_mean;
                m_needToRecomputeEigenVals = true;
                CRenderizableDisplayList::notifyChange();
                MRPT_END
        }
 
        /** Gets the current uncertainty covariance of parameter space */
        const cov_matrix_t& getCovMatrix() const { return m_cov; }
        /** Changes the scale of the "sigmas" for drawing the ellipse/ellipsoid
         *(default=3, ~97 or ~98% CI); the exact mathematical meaning is:
         *   This value of "quantiles" \a q should be set to the square root of the
         *chi-squared inverse cdf corresponding to
         *   the desired confidence interval.
         *   <b>Note that this value depends on the dimensionality</b>.
         *   Refer to the MATLAB functions \a chi2inv() and \a chi2cdf().
         *
         *  Some common values follow here for the convenience of users:
         *              - Dimensionality=3 (3D ellipsoids):
         *                      - 19.8748% CI -> q=1
         *                      - 73.8536% CI -> q=2
         *                      - 97.0709% CI -> q=3
         *                      - 99.8866% CI -> q=4
         *              - Dimensionality=2 (2D ellipses):
         *                      - 39.347% CI -> q=1
         *                      - 86.466% CI -> q=2
         *                      - 98.8891% CI -> q=3
         *                      - 99.9664% CI -> q=4
         *              - Dimensionality=1 (Not aplicable to this class but provided for
         *reference):
         *                      - 68.27% CI -> q=1
         *                      - 95.45% CI -> q=2
         *                      - 99.73% CI -> q=3
         *                      - 99.9937% CI -> q=4
         *
         */
        void setQuantiles(float q)
        {
                m_quantiles = q;
                CRenderizableDisplayList::notifyChange();
        }
        /** Refer to documentation of \a setQuantiles() */
        float getQuantiles() const { return m_quantiles; }
        /** The line width for 2D ellipses or 3D wireframe ellipsoids (default=1) */
        void setLineWidth(float w)
        {
                m_lineWidth = w;
                CRenderizableDisplayList::notifyChange();
        }
        float getLineWidth() const { return m_lineWidth; }
        /** Set the number of segments of the surface/curve (higher means with
         * greater resolution) */
        void setNumberOfSegments(const uint32_t numSegments)
        {
                m_numSegments = numSegments;
                CRenderizableDisplayList::notifyChange();
        }
        uint32_t getNumberOfSegments() { return m_numSegments; }
        /** Render
         *      If one of the eigen value of the covariance matrix of the ellipsoid is
         *null, ellipsoid will not
         * be rendered to ensure stability in the rendering process.
         */
        void render_dl() const override
        {
                MRPT_START
                // 1) Update eigenvectors/values:
                if (m_needToRecomputeEigenVals)
                {
                        m_needToRecomputeEigenVals = false;
                        // Handle the special case of an ellipsoid of volume = 0
                        const double d = m_cov.det();
                        if (fabs(d) < 1e-20 || d != d)  // Note: "d!=d" is a great test for
                        // invalid numbers, don't remove!
                        {
                                // All zeros:
                                m_U.setZero(DIM, DIM);
                        }
                        else
                        {
                                // Not null matrix:
                                m_cov.chol(m_U);
                        }
                }
 
                // Only if all the eigenvalues are !=0
                bool eig_ok = true;
                for (int i = 0; i < DIM; i++)
                        if (m_U.coeff(i, i) == 0) eig_ok = false;
 
                if (eig_ok)
                {
                        // 2) Generate "standard" ellipsoid:
                        std::vector<array_parameter_t> params_pts;
                        const cov_matrix_t Uscaled = static_cast<double>(m_quantiles) * m_U;
                        detail::generalizedEllipsoidPoints<DIM>(
                                Uscaled, m_mean, params_pts, m_numSegments, m_numSegments);
 
                        // 3) Transform into 2D/3D render space:
                        std::vector<array_point_t> render_pts;
                        this->transformFromParameterSpace(params_pts, render_pts);
 
                        // 3.5) Save bounding box:
                        m_bb_min = mrpt::math::TPoint3D(
                                std::numeric_limits<double>::max(),
                                std::numeric_limits<double>::max(), 0);
                        m_bb_max = mrpt::math::TPoint3D(
                                -std::numeric_limits<double>::max(),
                                -std::numeric_limits<double>::max(), 0);
                        for (size_t i = 0; i < render_pts.size(); i++)
                                for (int k = 0; k < DIM; k++)
                                {
                                        mrpt::keep_min(m_bb_min[k], render_pts[i][k]);
                                        mrpt::keep_max(m_bb_max[k], render_pts[i][k]);
                                }
                        // Convert to coordinates of my parent:
                        m_pose.composePoint(m_bb_min, m_bb_min);
                        m_pose.composePoint(m_bb_max, m_bb_max);
 
                        // 4) Render them:
                        mrpt::opengl::detail::renderGeneralizedEllipsoidTemplate<DIM>(
                                render_pts, m_lineWidth, m_numSegments, m_numSegments);
                }
 
                MRPT_END
        }
 
        /** Evaluates the bounding box of this object (including possible children)
         * in the coordinate frame of the object parent. */
        virtual void getBoundingBox(
                mrpt::math::TPoint3D& bb_min,
                mrpt::math::TPoint3D& bb_max) const override
        {
                bb_min = m_bb_min;
                bb_max = m_bb_max;
        }
 
        /** Ray tracing
         */
        virtual bool traceRay(
                const mrpt::poses::CPose3D& o, double& dist) const override
        {
                MRPT_UNUSED_PARAM(o);
                MRPT_UNUSED_PARAM(dist);
                THROW_EXCEPTION("Not implemented ");
        }
 
   protected:
        /** To be implemented by derived classes: maps, using some arbitrary space
         * transformation, a list of points
         *  defining an ellipsoid in parameter space into their corresponding
         * points in 2D/3D space.
         */
        virtual void transformFromParameterSpace(
                const std::vector<array_point_t>& params_pts,
                std::vector<array_point_t>& out_pts) const = 0;
 
        mutable cov_matrix_t m_cov;
        mean_vector_t m_mean;
        mutable bool m_needToRecomputeEigenVals;
        /** The number of "sigmas" for drawing the ellipse/ellipsoid (default=3) */
        float m_quantiles;
        /** The line width for 2D ellipses or 3D wireframe ellipsoids (default=1) */
        float m_lineWidth;
        /** Number of segments in 2D/3D ellipsoids (default=10) */
        uint32_t m_numSegments;
        mutable mrpt::math::TPoint3D m_bb_min, m_bb_max;
 
        /** Cholesky U triangular matrix cache. */
        mutable cov_matrix_t m_U;
 
        void thisclass_writeToStream(mrpt::serialization::CArchive& out) const
        {
                using namespace mrpt::math;
 
                const uint8_t version = 0;
                out << version << m_cov << m_mean << m_quantiles << m_lineWidth
                        << m_numSegments;
        }
        void thisclass_readFromStream(mrpt::serialization::CArchive& in)
        {
                uint8_t version;
                in >> version;
                switch (version)
                {
                        case 0:
                        {
                                in >> m_cov >> m_mean >> m_quantiles >> m_lineWidth >>
                                        m_numSegments;
                                m_needToRecomputeEigenVals = true;
                        }
                        break;
                        default:
                                MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
                };
                CRenderizableDisplayList::notifyChange();
        }
 
        CGeneralizedEllipsoidTemplate()
                : m_needToRecomputeEigenVals(true),
                  m_quantiles(3.f),
                  m_lineWidth(1.f),
                  m_numSegments(50),
                  m_bb_min(0, 0, 0),
                  m_bb_max(0, 0, 0)
        {
        }
        virtual ~CGeneralizedEllipsoidTemplate() {}
};
 
}  // namespace opengl
 
}  // namespace mrpt
 
#endif