The MRPT project: CGeneralizedCylinder.h Source File

Go to the documentation of this file.
00001 /* +---------------------------------------------------------------------------+
00002    |          The Mobile Robot Programming Toolkit (MRPT) C++ library          |
00003    |                                                                           |
00004    |                   http://mrpt.sourceforge.net/                            |
00005    |                                                                           |
00006    |   Copyright (C) 2005-2010  University of Malaga                           |
00007    |                                                                           |
00008    |    This software was written by the Machine Perception and Intelligent    |
00009    |      Robotics Lab, University of Malaga (Spain).                          |
00010    |    Contact: Jose-Luis Blanco  <jlblanco@ctima.uma.es>                     |
00011    |                                                                           |
00012    |  This file is part of the MRPT project.                                   |
00013    |                                                                           |
00014    |     MRPT is free software: you can redistribute it and/or modify          |
00015    |     it under the terms of the GNU General Public License as published by  |
00016    |     the Free Software Foundation, either version 3 of the License, or     |
00017    |     (at your option) any later version.                                   |
00018    |                                                                           |
00019    |   MRPT is distributed in the hope that it will be useful,                 |
00020    |     but WITHOUT ANY WARRANTY; without even the implied warranty of        |
00021    |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         |
00022    |     GNU General Public License for more details.                          |
00023    |                                                                           |
00024    |     You should have received a copy of the GNU General Public License     |
00025    |     along with MRPT.  If not, see <http://www.gnu.org/licenses/>.         |
00026    |                                                                           |
00027    +---------------------------------------------------------------------------+ */
00028 #ifndef opengl_CGeneralizedCylinder_H
00029 #define opengl_CGeneralizedCylinder_H
00030 
00031 #include <mrpt/opengl/CRenderizable.h>
00032 #include <mrpt/opengl/CPolyhedron.h>
00033 #include <mrpt/opengl/CSetOfTriangles.h>
00034 #include <mrpt/math/geometry.h>
00035 #include <mrpt/math/CMatrixTemplate.h>
00036 
00037 namespace mrpt  {
00038 namespace opengl        {
00039         using namespace mrpt::math;
00040         class MRPTDLLIMPEXP CGeneralizedCylinder;
00041         // This must be added to any CSerializable derived class:
00042         DEFINE_SERIALIZABLE_PRE_CUSTOM_BASE(CGeneralizedCylinder,CRenderizable)
00043         /**
00044           * 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.
00045           */
00046         class MRPTDLLIMPEXP CGeneralizedCylinder:public CRenderizable   {
00047                 DEFINE_SERIALIZABLE(CGeneralizedCylinder)
00048         public:
00049                 /**
00050                   * Auxiliary struct holding any quadrilateral, represented by foour points.
00051                   */
00052                 struct MRPTDLLIMPEXP TQuadrilateral     {
00053                 private:
00054                         /**
00055                           * Automatically compute a vector normal to this quadrilateral.
00056                           */
00057                         void calculateNormal();
00058                 public:
00059                         /**
00060                           * Quadrilateral`'s points.
00061                           */
00062                         TPoint3D points[4];
00063                         /**
00064                           * Normal vector.
00065                           */ 
00066                         float normal[3];
00067                         /**
00068                           * Given a polygon with 4 already positions allocated, this method fills it with the quadrilateral points.
00069                           * \sa mrpt::math::TPolygon3D
00070                           */ 
00071                         inline void getAsPolygonUnsafe(mrpt::math::TPolygon3D &vec) const       {
00072                                 vec[0]=points[0];
00073                                 vec[1]=points[1];
00074                                 vec[2]=points[2];
00075                                 vec[3]=points[3];
00076                         }
00077                         /**
00078                           * Constructor from 4 points.
00079                           */ 
00080                         TQuadrilateral(const TPoint3D &p1,const TPoint3D &p2,const TPoint3D &p3,const TPoint3D &p4)     {
00081                                 points[0]=p1;
00082                                 points[1]=p2;
00083                                 points[2]=p3;
00084                                 points[3]=p4;
00085                                 calculateNormal();
00086                         }
00087                         /**
00088                           * Construction from any array of four compatible objects.
00089                           */ 
00090                         template<class T> TQuadrilateral(const T (&p)[4])       {
00091                                 for (int i=0;i<4;i++) points[i]=p[i];
00092                                 calculateNormal();
00093                         }
00094                         /**
00095                           * Empty constructor. Initializes to garbage.
00096                           */ 
00097                         TQuadrilateral()        {}
00098                         /**
00099                           * Destructor.
00100                           */ 
00101                         ~TQuadrilateral()       {}
00102                 };
00103         protected:
00104                 /**
00105                   * Cylinder's axis. It's represented as a pose because it holds the angle to get to the next pose.
00106                   */
00107                 vector<CPose3D> axis;
00108                 /**
00109                   * Object's generatrix, that is, profile which will be extruded.
00110                   */
00111                 vector<TPoint3D> generatrix;
00112                 /**
00113                   * Mutable object with mesh information, used to avoid repeated computations.
00114                   */
00115                 mutable std::vector<TQuadrilateral> mesh;
00116                 /**
00117                   * Mutable object with the cylinder's points, used to avoid repeated computations.
00118                   */
00119                 mutable CMatrixTemplate<TPoint3D> pointsMesh;
00120                 /**
00121                   * Mutable flag which tells if recalculations are needed.
00122                   */
00123                 mutable bool meshUpToDate;
00124                 /**
00125                   * Mutable set of data used in ray tracing.
00126                   * \sa mrpt::math::TPolygonWithPlane
00127                   */
00128                 mutable vector<TPolygonWithPlane> polys;
00129                 /**
00130                   * Mutable flag telling whether ray tracing temporary data must be recalculated or not.
00131                   */
00132                 mutable bool polysUpToDate;
00133                 /**
00134                   * Boolean variable which determines if the profile is closed at each section.
00135                   */
00136                 bool closed;
00137                 /**
00138                   * Flag to determine whether the object is fully visible or only some sections are.
00139                   */
00140                 bool fullyVisible;
00141                 /**
00142                   * First visible section, if fullyVisible is set to false.
00143                   * \sa fullyVisible,lastSection
00144                   */
00145                 size_t firstSection;
00146                 /**
00147                   * Last visible section, if fullyVisible is set to false.
00148                   * \sa fullyVisible,firstSection
00149                   */
00150                 size_t lastSection;
00151         public:
00152                 /**
00153                   * Creation of generalized cylinder from axis and generatrix
00154                   */
00155                 static CGeneralizedCylinderPtr Create(const std::vector<TPoint3D> &axis,const std::vector<TPoint3D> &generatrix)        {
00156                         return CGeneralizedCylinderPtr(new CGeneralizedCylinder(axis,generatrix));
00157                 }
00158                 /**
00159                   * Render.
00160                   * \sa mrpt::opengl::CRenderizable
00161                   */
00162                 void render() const;
00163                 /**
00164                   * Ray tracing.
00165                   * \sa mrpt::opengl::CRenderizable.
00166                   */
00167                 virtual bool traceRay(const mrpt::poses::CPose3D &o,double &dist) const;
00168                 /**
00169                   * Get axis's spatial coordinates.
00170                   */
00171                 inline void getAxis(std::vector<TPoint3D> &a) const     {
00172                         //a=axis;
00173                         size_t N=axis.size();
00174                         a.resize(N);
00175                         for (size_t i=0;i<N;i++)        {
00176                                 a[i].x=axis[i].x();
00177                                 a[i].y=axis[i].y();
00178                                 a[i].z=axis[i].z();
00179                         }
00180                 }
00181                 /**
00182                   * Get axis, including angular coordinates.
00183                   */
00184                 inline void getAxis(std::vector<CPose3D> &a) const      {
00185                         a=axis;
00186                 }
00187                 /**
00188                   * Set the axis points.
00189                   */
00190                 inline void setAxis(const std::vector<TPoint3D> &a)     {
00191                         generatePoses(a,axis);
00192                         meshUpToDate=false;
00193                         fullyVisible=true;
00194                 }
00195                 /**
00196                   * Get cylinder's profile.
00197                   */
00198                 inline void getGeneratrix(std::vector<TPoint3D> &g) const       {
00199                         g=generatrix;
00200                 }
00201                 /**
00202                   * Set cylinder's profile.
00203                   */
00204                 inline void setGeneratrix(const std::vector<TPoint3D> g)        {
00205                         generatrix=g;
00206                         meshUpToDate=false;
00207                 }
00208                 /**
00209                   * Returns true if each section is a closed polygon.
00210                   */
00211                 inline bool isClosed() const    {
00212                         return closed;
00213                 }
00214                 /**
00215                   * Set whether each section is a closed polygon or not.
00216                   */
00217                 inline void setClosed(bool c=true)      {
00218                         closed=c;
00219                         meshUpToDate=false;
00220                 }
00221                 /**
00222                   * Get a polyhedron containing the starting point of the cylinder (its "base").
00223                   * \sa getEnd,mrpt::opengl::CPolyhedron
00224                   */
00225                 void getOrigin(CPolyhedronPtr &poly) const;
00226                 /**
00227                   * Get a polyhedron containing the ending point of the cylinder (its "base").
00228                   * \sa getOrigin,mrpt::opengl::CPolyhedron
00229                   */
00230                 void getEnd(CPolyhedronPtr &poly) const;
00231                 /**
00232                   * Get the cylinder as a set of polygons in 3D.
00233                   * \sa mrpt::math::TPolygon3D
00234                   */
00235                 void generateSetOfPolygons(std::vector<TPolygon3D> &res) const;
00236                 /**
00237                   * Get a polyhedron consisting of a set of closed sections of the cylinder.
00238                   * \sa mrpt::opengl::CPolyhedron
00239                   */
00240                 void getClosedSection(size_t index1,size_t index2,CPolyhedronPtr &poly) const;
00241                 /**
00242                   * Get a polyhedron consisting of a single section of the cylinder.
00243                   * \sa mrpt::opengl::CPolyhedron
00244                   */
00245                 inline void getClosedSection(size_t index,CPolyhedronPtr &poly) const   {
00246                         getClosedSection(index,index,poly);
00247                 }
00248                 /**
00249                   * Get the number of sections in this cylinder.
00250                   */
00251                 inline size_t getNumberOfSections() const       {
00252                         return axis.size()?(axis.size()-1):0;
00253                 }
00254                 /**
00255                   * Get how many visible sections are in the cylinder.
00256                   */
00257                 inline size_t getVisibleSections() const        {
00258                         return fullyVisible?getNumberOfSections():(lastSection-firstSection);
00259                 }
00260                 /**
00261                   * Gets the cylinder's visible sections.
00262                   */
00263                 void getVisibleSections(size_t &first,size_t &last) const       {
00264                         if (fullyVisible)       {
00265                                 first=0;
00266                                 last=getNumberOfSections();
00267                         }       else    {
00268                                 first=firstSection;
00269                                 last=lastSection;
00270                         }
00271                 }
00272                 /**
00273                   * Sets all sections visible.
00274                   */
00275                 inline void setAllSectionsVisible()     {
00276                         fullyVisible=true;
00277                 }
00278                 /**
00279                   * Hides all sections.
00280                   */
00281                 inline void setAllSectionsInvisible(size_t pointer=0)   {
00282                         fullyVisible=false;
00283                         firstSection=pointer;
00284                         lastSection=pointer;
00285                 }
00286                 /**
00287                   * Sets which sections are visible.
00288                   * \throw std::logic_error on wrongly defined bounds.
00289                   */
00290                 inline void setVisibleSections(size_t first,size_t last)        {
00291                         fullyVisible=false;
00292                         if (first>last||last>getNumberOfSections()) throw std::logic_error("Wrong bound definition");
00293                         firstSection=first;
00294                         lastSection=last;
00295                 }
00296                 /**
00297                   * Adds another visible section at the start of the cylinder. The cylinder must have an invisble section to display.
00298                   * \throw std::logic_error if there is no section to add to the displaying set.
00299                   * \sa addVisibleSectionAtEnd,removeVisibleSectionAtStart,removeVisibleSectionAtEnd
00300                   */
00301                 inline void addVisibleSectionAtStart()  {
00302                         if (fullyVisible||firstSection==0) throw std::logic_error("No more sections");
00303                         firstSection--;
00304                 }
00305                 /**
00306                   * Adds another visible section at the end of the cylinder. The cylinder must have an invisible section to display.
00307                   * \throw std::logic_error if there is no section to add to the displaying set.
00308                   * \sa addVisibleSectionAtStart,removeVisibleSectionAtStart,removeVisibleSectionAtEnd
00309                   */
00310                 inline void addVisibleSectionAtEnd()    {
00311                         if (fullyVisible||lastSection==getNumberOfSections()) throw std::logic_error("No more sections");
00312                         lastSection++;
00313                 }
00314                 /**
00315                   * Removes a visible section from the start of the currently visible set.
00316                   * \throw std::logic_error if there are no visible sections.
00317                   * \sa addVisibleSectionAtStart,addVisibleSectionAtEnd,removeVisibleSectionAtEnd
00318                   */
00319                 void removeVisibleSectionAtStart();
00320                 /**
00321                   * Removes a visible section from the ending of the currently visible set.
00322                   * \throw std::logic_error when there is no such section.
00323                   * \sa addVisibleSectionAtStart,addVisibleSectionAtEnd,removeVisibleSectionAtStart
00324                   */
00325                 void removeVisibleSectionAtEnd();
00326                 /**
00327                   * Gets the axis pose of the first section, returning false if there is no such pose.
00328                   */
00329                 bool getFirstSectionPose(mrpt::poses::CPose3D &p);
00330                 /**
00331                   * Gets the axis pose of the last section, returning false if there is no such pose.
00332                   */
00333                 bool getLastSectionPose(mrpt::poses::CPose3D &p);
00334                 /**
00335                   * Gets the axis pose of the first visible section, returning false if there is no such pose.
00336                   */
00337                 bool getFirstVisibleSectionPose(mrpt::poses::CPose3D &p);
00338                 /**
00339                   * Gets the axis pose of the last section, returning false if there is no such pose.
00340                   */
00341                 bool getLastVisibleSectionPose(mrpt::poses::CPose3D &p);
00342                 /**
00343                   * Updates the mutable set of polygons used in ray tracing.
00344                   */
00345                 void updatePolys() const;
00346         private:
00347                 /**
00348                   * Updates the axis, transforming each point into a pose pointing to the next section.
00349                   */
00350                 void generatePoses(const std::vector<TPoint3D> &pIn,std::vector<CPose3D> &pOut);
00351                 /**
00352                   * Updates the mutable mesh.
00353                   */
00354                 void updateMesh() const;
00355                 /**
00356                   * Given a vector of polyhedrons, gets the starting and ending iterators to the section to be actually rendered.
00357                   */
00358                 void getMeshIterators(const vector<TQuadrilateral> &m,vector<TQuadrilateral>::const_iterator &begin,vector<TQuadrilateral>::const_iterator &end) const;
00359                 /**
00360                   * Basic constructor with default initialization.
00361                   */
00362                 CGeneralizedCylinder():axis(),generatrix(),mesh(),meshUpToDate(false),polysUpToDate(false),closed(false),fullyVisible(true)     {}
00363                 /**
00364                   * Constructor with axis and generatrix.
00365                   */
00366                 CGeneralizedCylinder(const std::vector<TPoint3D> &a,const std::vector<TPoint3D> &g):generatrix(g),mesh(),meshUpToDate(false),polysUpToDate(false),closed(false),fullyVisible(true)      {
00367                         generatePoses(a,axis);
00368                 }
00369                 /**
00370                   * Destructor.
00371                   */
00372                 virtual ~CGeneralizedCylinder() {};
00373         };
00374 }
00375 }
00376 #endif