Point Cloud Library (PCL)  1.9.1-dev
common.h
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Copyright (c) 2010, Willow Garage, Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above
14  * copyright notice, this list of conditions and the following
15  * disclaimer in the documentation and/or other materials provided
16  * with the distribution.
17  * * Neither the name of Willow Garage, Inc. nor the names of its
18  * contributors may be used to endorse or promote products derived
19  * from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  *
34  * $Id$
35  *
36  */
37 
38 #pragma once
39 
40 #if defined __GNUC__
41 #pragma GCC system_header
42 #endif
43 
44 #include <pcl/pcl_macros.h>
45 #include <pcl/visualization/eigen.h>
46 #include <vtkMatrix4x4.h>
47 #include <vtkSmartPointer.h>
48 #include <vtkLookupTable.h>
49 
50 class vtkCamera;
51 class vtkRenderWindow;
52 
53 namespace pcl
54 {
55  struct RGB;
56 
57  namespace visualization
58  {
59  /** \brief Get (good) random values for R/G/B.
60  * \param[out] r the resultant R color value
61  * \param[out] g the resultant G color value
62  * \param[out] b the resultant B color value
63  * \param[in] min minimum value for the colors
64  * \param[in] max maximum value for the colors
65  */
66  PCL_EXPORTS void
67  getRandomColors (double &r, double &g, double &b, double min = 0.2, double max = 2.8);
68 
69  /** \brief Get (good) random values for R/G/B.
70  * \param[out] rgb the resultant RGB color value
71  * \param[in] min minimum value for the colors
72  * \param[in] max maximum value for the colors
73  */
74  PCL_EXPORTS void
75  getRandomColors (pcl::RGB &rgb, double min = 0.2, double max = 2.8);
76 
77  PCL_EXPORTS Eigen::Matrix4d
78  vtkToEigen (vtkMatrix4x4* vtk_matrix);
79 
80  PCL_EXPORTS Eigen::Vector2i
81  worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height);
82 
83  PCL_EXPORTS void
84  getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24]);
85 
87  {
91  };
92 
93  PCL_EXPORTS int
94  cullFrustum (double planes[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb);
95 
96  PCL_EXPORTS float
97  viewScreenArea (const Eigen::Vector3d &eye, const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, const Eigen::Matrix4d &view_projection_matrix, int width, int height);
98 
99  /** \brief Set of rendering properties. */
101  {
102  PCL_VISUALIZER_POINT_SIZE, /**< integer starting from 1 */
103  PCL_VISUALIZER_OPACITY, /**< Float going from 0.0 (transparent) to 1.0 (opaque) */
104  PCL_VISUALIZER_LINE_WIDTH, /**< Integer starting from 1 */
106  PCL_VISUALIZER_COLOR, /**< 3 floats (R, G, B) going from 0.0 (dark) to 1.0 (light) */
110  PCL_VISUALIZER_LUT, /**< colormap type \ref pcl::visualization::LookUpTableRepresentationProperties */
111  PCL_VISUALIZER_LUT_RANGE /**< two doubles (min and max) or \ref pcl::visualization::LookUpTableRepresentationProperties::PCL_VISUALIZER_LUT_RANGE_AUTO */
112  };
113 
115  {
119  };
120 
122  {
126  };
127 
128  /*! Colormap properties. See [mathworks colormap page](http://www.mathworks.com/help/matlab/ref/colormap.html#input_argument_name) for image representations of the colormaps. */
130  {
131  PCL_VISUALIZER_LUT_JET, /**< Jet colormap */
132  PCL_VISUALIZER_LUT_JET_INVERSE, /**< Inverse jet colormap */
133  PCL_VISUALIZER_LUT_HSV, /**< HSV colormap */
134  PCL_VISUALIZER_LUT_HSV_INVERSE, /**< Inverse HSV colormap */
135  PCL_VISUALIZER_LUT_GREY, /**< Grey colormap (black to white) */
136  PCL_VISUALIZER_LUT_BLUE2RED, /**< Blue to red colormap (blue to white to red) */
137  PCL_VISUALIZER_LUT_RANGE_AUTO, /**< Set LUT range to min and max values of the data */
138  PCL_VISUALIZER_LUT_VIRIDIS /**< Viridis colormap */
139  };
140 
141  /** \brief Generate a lookup table for a colormap.
142  * \param[in] colormap_type
143  * \param[out] table a vtk lookup table
144  * \note The list of available colormaps can be found in \ref pcl::visualization::LookUpTableRepresentationProperties.
145  */
146  PCL_EXPORTS bool
148 
149  //////////////////////////////////////////////////////////////////////////////////////////////
150  /** \brief Camera class holds a set of camera parameters together with the window pos/size. */
152  {
153  public:
154  /** Construct a camera with meaningful default values.
155  * The camera is positioned at origin, looks along z-axis and has up-vector along y-axis. Window position and
156  * size are initialized with (0, 0) and (1, 1) respectively. */
157  Camera ();
158 
159  /** Construct a camera by copying parameters from a VTK camera.
160  * Window position and size are initialized with (0, 0) and (1, 1) respectively.*/
161  Camera (vtkCamera& camera);
162 
163  /** Construct a camera by copying parameters from a VTK camera and a VTK render window. */
164  Camera (vtkCamera& camera, vtkRenderWindow& window);
165 
166  /** \brief Focal point or lookAt.
167  * \note The view direction can be obtained by (focal-pos).normalized ()
168  */
169  double focal[3];
170 
171  /** \brief Position of the camera. */
172  double pos[3];
173 
174  /** \brief Up vector of the camera.
175  * \note Not to be confused with the view direction, bad naming here. */
176  double view[3];
177 
178  /** \brief Clipping planes depths.
179  * clip[0] is near clipping plane, and clip [1] is the far clipping plane
180  */
181  double clip[2];
182 
183  /** \brief Field of view angle in y direction (radians). */
184  double fovy;
185 
186  // the following variables are the actual position and size of the window on the screen and NOT the viewport!
187  // except for the size, which is the same the viewport is assumed to be centered and same size as the window.
188  double window_size[2];
189  double window_pos[2];
190 
191 
192  /** \brief Computes View matrix for Camera (Based on gluLookAt)
193  * \param[out] view_mat the resultant matrix
194  */
195  void
196  computeViewMatrix (Eigen::Matrix4d& view_mat) const;
197 
198  /** \brief Computes Projection Matrix for Camera
199  * \param[out] proj the resultant matrix
200  */
201  void
202  computeProjectionMatrix (Eigen::Matrix4d& proj) const;
203 
204  /** \brief converts point to window coordiantes
205  * \param[in] pt xyz point to be converted
206  * \param[out] window_cord vector containing the pts' window X,Y, Z and 1
207  *
208  * This function computes the projection and view matrix every time.
209  * It is very inefficient to use this for every point in the point cloud!
210  */
211  template<typename PointT> void
212  cvtWindowCoordinates (const PointT& pt, Eigen::Vector4d& window_cord) const;
213 
214  /** \brief converts point to window coordiantes
215  * \param[in] pt xyz point to be converted
216  * \param[out] window_cord vector containing the pts' window X,Y, Z and 1
217  * \param[in] composite_mat composite transformation matrix (proj*view)
218  *
219  * Use this function to compute window coordinates with a precomputed
220  * transformation function. The typical composite matrix will be
221  * the projection matrix * the view matrix. However, additional
222  * matrices like a camera disortion matrix can also be added.
223  */
224  template<typename PointT> void
225  cvtWindowCoordinates (const PointT& pt, Eigen::Vector4d& window_cord, const Eigen::Matrix4d& composite_mat) const;
226  };
227  }
228 }
229 
230 #include <pcl/visualization/common/impl/common.hpp>
Grey colormap (black to white)
Definition: common.h:135
PCL_EXPORTS void getViewFrustum(const Eigen::Matrix4d &view_projection_matrix, double planes[24])
This file defines compatibility wrappers for low level I/O functions.
Definition: convolution.h:45
Camera class holds a set of camera parameters together with the window pos/size.
Definition: common.h:151
LookUpTableRepresentationProperties
Definition: common.h:129
Float going from 0.0 (transparent) to 1.0 (opaque)
Definition: common.h:103
RenderingProperties
Set of rendering properties.
Definition: common.h:100
two doubles (min and max) or pcl::visualization::LookUpTableRepresentationProperties::PCL_VISUALIZER_...
Definition: common.h:111
PCL_EXPORTS void getRandomColors(double &r, double &g, double &b, double min=0.2, double max=2.8)
Get (good) random values for R/G/B.
A structure representing RGB color information.
3 floats (R, G, B) going from 0.0 (dark) to 1.0 (light)
Definition: common.h:106
PCL_EXPORTS Eigen::Matrix4d vtkToEigen(vtkMatrix4x4 *vtk_matrix)
Blue to red colormap (blue to white to red)
Definition: common.h:136
PCL_EXPORTS float viewScreenArea(const Eigen::Vector3d &eye, const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, const Eigen::Matrix4d &view_projection_matrix, int width, int height)
colormap type pcl::visualization::LookUpTableRepresentationProperties
Definition: common.h:110
Set LUT range to min and max values of the data.
Definition: common.h:137
PCL_EXPORTS bool getColormapLUT(LookUpTableRepresentationProperties colormap_type, vtkSmartPointer< vtkLookupTable > &table)
Generate a lookup table for a colormap.
RenderingRepresentationProperties
Definition: common.h:114
double fovy
Field of view angle in y direction (radians).
Definition: common.h:184
A point structure representing Euclidean xyz coordinates, and the RGB color.
ShadingRepresentationProperties
Definition: common.h:121
#define PCL_EXPORTS
Definition: pcl_macros.h:241
PCL_EXPORTS Eigen::Vector2i worldToView(const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height)
PCL_EXPORTS int cullFrustum(double planes[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb)
Defines all the PCL and non-PCL macros used.