CGeneralizedCylinder.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_CGeneralizedCylinder_H
#define opengl_CGeneralizedCylinder_H
 
#include <mrpt/opengl/CRenderizableDisplayList.h>
#include <mrpt/opengl/CPolyhedron.h>
#include <mrpt/opengl/CSetOfTriangles.h>
#include <mrpt/math/geometry.h>
#include <mrpt/math/CMatrixTemplate.h>
#include <mrpt/core/aligned_std_vector.h>
 
namespace mrpt
{
namespace opengl
{
class CGeneralizedCylinder;
/**
 * This object represents any figure obtained by extruding any profile along a
 * given axis. The profile should lie over a x=0 plane, and the axis must be
 * roughly perpendicular to this plane. In particular, it should be almost
 * perpendicular to the Z axis.
 * \ingroup mrpt_opengl_grp
 */
class CGeneralizedCylinder : public CRenderizableDisplayList
{
        DEFINE_SERIALIZABLE(CGeneralizedCylinder)
   public:
        /**
         * Auxiliary struct holding any quadrilateral, represented by foour points.
         */
        struct TQuadrilateral
        {
           private:
                /**
                 * Automatically compute a vector normal to this quadrilateral.
                 */
                void calculateNormal();
 
           public:
                /**
                 * Quadrilateral`'s points.
                 */
                mrpt::math::TPoint3D points[4];
                /**
                 * Normal vector.
                 */
                double normal[3];
                /**
                 * Given a polygon with 4 already positions allocated, this method
                 * fills it with the quadrilateral points.
                 * \sa mrpt::math::TPolygon3D
                 */
                inline void getAsPolygonUnsafe(mrpt::math::TPolygon3D& vec) const
                {
                        vec[0] = points[0];
                        vec[1] = points[1];
                        vec[2] = points[2];
                        vec[3] = points[3];
                }
                /**
                 * Constructor from 4 points.
                 */
                TQuadrilateral(
                        const mrpt::math::TPoint3D& p1, const mrpt::math::TPoint3D& p2,
                        const mrpt::math::TPoint3D& p3, const mrpt::math::TPoint3D& p4)
                {
                        points[0] = p1;
                        points[1] = p2;
                        points[2] = p3;
                        points[3] = p4;
                        calculateNormal();
                }
                /**
                 * Construction from any array of four compatible objects.
                 */
                template <class T>
                TQuadrilateral(const T (&p)[4])
                {
                        for (int i = 0; i < 4; i++) points[i] = p[i];
                        calculateNormal();
                }
                /**
                 * Empty constructor. Initializes to garbage.
                 */
                TQuadrilateral() {}
                /**
                 * Destructor.
                 */
                ~TQuadrilateral() {}
        };
 
   protected:
        /** Cylinder's axis. It's represented as a pose because it holds the angle
         * to get to the next pose. */
        mrpt::aligned_std_vector<mrpt::poses::CPose3D> axis;
        /**  Object's generatrix, that is, profile which will be extruded. */
        std::vector<mrpt::math::TPoint3D> generatrix;
        /** Mutable object with mesh information, used to avoid repeated
         * computations.  */
        mutable std::vector<TQuadrilateral> mesh;
        /** Mutable object with the cylinder's points, used to avoid repeated
         * computations. */
        mutable mrpt::math::CMatrixTemplate<mrpt::math::TPoint3D> pointsMesh;
        /**  Mutable flag which tells if recalculations are needed. */
        mutable bool meshUpToDate;
        /**
         * Mutable set of data used in ray tracing.
         * \sa mrpt::math::TPolygonWithPlane
         */
        mutable std::vector<mrpt::math::TPolygonWithPlane> polys;
        /** Mutable flag telling whether ray tracing temporary data must be
         * recalculated or not. */
        mutable bool polysUpToDate;
        /** Boolean variable which determines if the profile is closed at each
         * section. */
        bool closed;
        /** Flag to determine whether the object is fully visible or only some
         * sections are. */
        bool fullyVisible;
        /**
         * First visible section, if fullyVisible is set to false.
         * \sa fullyVisible,lastSection
         */
        size_t firstSection;
        /**
         * Last visible section, if fullyVisible is set to false.
         * \sa fullyVisible,firstSection
         */
        size_t lastSection;
 
   public:
        /**
         * Creation of generalized cylinder from axis and generatrix
         */
        static CGeneralizedCylinder::Ptr Create(
                const std::vector<mrpt::math::TPoint3D>& axis,
                const std::vector<mrpt::math::TPoint3D>& generatrix);
        /**
         * Render.
         * \sa mrpt::opengl::CRenderizable
         */
        void render_dl() const override;
        /**
         * Ray tracing.
         * \sa mrpt::opengl::CRenderizable.
         */
        bool traceRay(const mrpt::poses::CPose3D& o, double& dist) const override;
        /**
         * Get axis's spatial coordinates.
         */
        inline void getAxis(std::vector<mrpt::math::TPoint3D>& a) const
        {
                // a=axis;
                size_t N = axis.size();
                a.resize(N);
                for (size_t i = 0; i < N; i++)
                {
                        a[i].x = axis[i].x();
                        a[i].y = axis[i].y();
                        a[i].z = axis[i].z();
                }
        }
        /**
         * Get axis, including angular coordinates.
         */
        inline void getAxis(mrpt::aligned_std_vector<mrpt::poses::CPose3D>& a) const
        {
                a = axis;
        }
        /**
         * Set the axis points.
         */
        inline void setAxis(const std::vector<mrpt::math::TPoint3D>& a)
        {
                generatePoses(a, axis);
                meshUpToDate = false;
                fullyVisible = true;
                CRenderizableDisplayList::notifyChange();
        }
        /**
         * Get cylinder's profile.
         */
        inline void getGeneratrix(std::vector<mrpt::math::TPoint3D>& g) const
        {
                g = generatrix;
        }
        /**
         * Set cylinder's profile.
         */
        inline void setGeneratrix(const std::vector<mrpt::math::TPoint3D>& g)
        {
                generatrix = g;
                meshUpToDate = false;
                CRenderizableDisplayList::notifyChange();
        }
        /**
         * Returns true if each section is a closed polygon.
         */
        inline bool isClosed() const { return closed; }
        /**
         * Set whether each section is a closed polygon or not.
         */
        inline void setClosed(bool c = true)
        {
                closed = c;
                meshUpToDate = false;
                CRenderizableDisplayList::notifyChange();
        }
        /**
         * Get a polyhedron containing the starting point of the cylinder (its
         * "base").
         * \sa getEnd,mrpt::opengl::CPolyhedron
         */
        void getOrigin(CPolyhedron::Ptr& poly) const;
        /**
         * Get a polyhedron containing the ending point of the cylinder (its
         * "base").
         * \sa getOrigin,mrpt::opengl::CPolyhedron
         */
        void getEnd(CPolyhedron::Ptr& poly) const;
        /**
         * Get the cylinder as a set of polygons in 3D.
         * \sa mrpt::math::TPolygon3D
         */
        void generateSetOfPolygons(std::vector<mrpt::math::TPolygon3D>& res) const;
        /**
         * Get a polyhedron consisting of a set of closed sections of the cylinder.
         * \sa mrpt::opengl::CPolyhedron
         */
        void getClosedSection(
                size_t index1, size_t index2, CPolyhedron::Ptr& poly) const;
        /**
         * Get a polyhedron consisting of a single section of the cylinder.
         * \sa mrpt::opengl::CPolyhedron
         */
        inline void getClosedSection(size_t index, CPolyhedron::Ptr& poly) const
        {
                getClosedSection(index, index, poly);
        }
        /**
         * Get the number of sections in this cylinder.
         */
        inline size_t getNumberOfSections() const
        {
                return axis.size() ? (axis.size() - 1) : 0;
        }
        /**
         * Get how many visible sections are in the cylinder.
         */
        inline size_t getVisibleSections() const
        {
                return fullyVisible ? getNumberOfSections()
                                                        : (lastSection - firstSection);
        }
        /**
         * Gets the cylinder's visible sections.
         */
        void getVisibleSections(size_t& first, size_t& last) const
        {
                if (fullyVisible)
                {
                        first = 0;
                        last = getNumberOfSections();
                }
                else
                {
                        first = firstSection;
                        last = lastSection;
                }
        }
        /**
         * Sets all sections visible.
         */
        inline void setAllSectionsVisible()
        {
                fullyVisible = true;
                CRenderizableDisplayList::notifyChange();
        }
        /**
         * Hides all sections.
         */
        inline void setAllSectionsInvisible(size_t pointer = 0)
        {
                fullyVisible = false;
                firstSection = pointer;
                lastSection = pointer;
                CRenderizableDisplayList::notifyChange();
        }
        /**
         * Sets which sections are visible.
         * \throw std::logic_error on wrongly defined bounds.
         */
        inline void setVisibleSections(size_t first, size_t last)
        {
                fullyVisible = false;
                if (first > last || last > getNumberOfSections())
                        throw std::logic_error("Wrong bound definition");
                firstSection = first;
                lastSection = last;
                CRenderizableDisplayList::notifyChange();
        }
        /**
         * Adds another visible section at the start of the cylinder. The cylinder
         * must have an invisble section to display.
         * \throw std::logic_error if there is no section to add to the displaying
         * set.
         * \sa
         * addVisibleSectionAtEnd,removeVisibleSectionAtStart,removeVisibleSectionAtEnd
         */
        inline void addVisibleSectionAtStart()
        {
                if (fullyVisible || firstSection == 0)
                        throw std::logic_error("No more sections");
                firstSection--;
                CRenderizableDisplayList::notifyChange();
        }
        /**
         * Adds another visible section at the end of the cylinder. The cylinder
         * must have an invisible section to display.
         * \throw std::logic_error if there is no section to add to the displaying
         * set.
         * \sa
         * addVisibleSectionAtStart,removeVisibleSectionAtStart,removeVisibleSectionAtEnd
         */
        inline void addVisibleSectionAtEnd()
        {
                if (fullyVisible || lastSection == getNumberOfSections())
                        throw std::logic_error("No more sections");
                lastSection++;
                CRenderizableDisplayList::notifyChange();
        }
        /**
         * Removes a visible section from the start of the currently visible set.
         * \throw std::logic_error if there are no visible sections.
         * \sa
         * addVisibleSectionAtStart,addVisibleSectionAtEnd,removeVisibleSectionAtEnd
         */
        void removeVisibleSectionAtStart();
        /**
         * Removes a visible section from the ending of the currently visible set.
         * \throw std::logic_error when there is no such section.
         * \sa
         * addVisibleSectionAtStart,addVisibleSectionAtEnd,removeVisibleSectionAtStart
         */
        void removeVisibleSectionAtEnd();
        /**
         * Gets the axis pose of the first section, returning false if there is no
         * such pose.
         */
        bool getFirstSectionPose(mrpt::poses::CPose3D& p);
        /**
         * Gets the axis pose of the last section, returning false if there is no
         * such pose.
         */
        bool getLastSectionPose(mrpt::poses::CPose3D& p);
        /**
         * Gets the axis pose of the first visible section, returning false if
         * there is no such pose.
         */
        bool getFirstVisibleSectionPose(mrpt::poses::CPose3D& p);
        /**
         * Gets the axis pose of the last section, returning false if there is no
         * such pose.
         */
        bool getLastVisibleSectionPose(mrpt::poses::CPose3D& p);
        /**
         * Updates the mutable set of polygons used in ray tracing.
         */
        void updatePolys() const;
 
        /** Evaluates the bounding box of this object (including possible children)
         * in the coordinate frame of the object parent. */
        void getBoundingBox(
                mrpt::math::TPoint3D& bb_min,
                mrpt::math::TPoint3D& bb_max) const override;
 
   private:
        /**
         * Updates the axis, transforming each point into a pose pointing to the
         * next section.
         */
        void generatePoses(
                const std::vector<mrpt::math::TPoint3D>& pIn,
                mrpt::aligned_std_vector<mrpt::poses::CPose3D>& pOut);
        /**
         * Updates the mutable mesh.
         */
        void updateMesh() const;
        /**
         * Given a vector of polyhedrons, gets the starting and ending iterators to
         * the section to be actually rendered.
         */
        void getMeshIterators(
                const std::vector<TQuadrilateral>& m,
                std::vector<TQuadrilateral>::const_iterator& begin,
                std::vector<TQuadrilateral>::const_iterator& end) const;
 
   public:
        /**
         * Basic constructor with default initialization.
         */
        CGeneralizedCylinder()
                : axis(),
                  generatrix(),
                  mesh(),
                  meshUpToDate(false),
                  polysUpToDate(false),
                  closed(false),
                  fullyVisible(true)
        {
        }
        /**
         * Constructor with axis and generatrix.
         */
        CGeneralizedCylinder(
                const std::vector<mrpt::math::TPoint3D>& a,
                const std::vector<mrpt::math::TPoint3D>& g)
                : generatrix(g),
                  mesh(),
                  meshUpToDate(false),
                  polysUpToDate(false),
                  closed(false),
                  fullyVisible(true)
        {
                generatePoses(a, axis);
        }
        /**
         * Destructor.
         */
        virtual ~CGeneralizedCylinder(){};
};
}  // namespace opengl
}  // namespace mrpt
#endif