Point Cloud Library (PCL) 1.12.0
Loading...
Searching...
No Matches
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 <Eigen/Core> // for Matrix, ...
45
46#include <pcl/pcl_macros.h>
47#include <vtkMatrix4x4.h>
48#include <vtkSmartPointer.h>
49#include <vtkLookupTable.h>
50
51class vtkCamera;
52class vtkRenderWindow;
53
54namespace pcl
55{
56 struct RGB;
57
58 namespace visualization
59 {
60 /** \brief Get (good) random values for R/G/B.
61 * \param[out] r the resultant R color value
62 * \param[out] g the resultant G color value
63 * \param[out] b the resultant B color value
64 * \param[in] min minimum value for the colors
65 * \param[in] max maximum value for the colors
66 */
67 PCL_EXPORTS void
68 getRandomColors (double &r, double &g, double &b, double min = 0.2, double max = 2.8);
69
70 /** \brief Get (good) random values for R/G/B.
71 * \param[out] rgb the resultant RGB color value
72 * \param[in] min minimum value for the colors
73 * \param[in] max maximum value for the colors
74 */
75 PCL_EXPORTS void
76 getRandomColors (pcl::RGB &rgb, double min = 0.2, double max = 2.8);
77
78 PCL_EXPORTS Eigen::Matrix4d
79 vtkToEigen (vtkMatrix4x4* vtk_matrix);
80
81 PCL_EXPORTS Eigen::Vector2i
82 worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height);
83
84 PCL_EXPORTS void
85 getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24]);
86
93
94 PCL_EXPORTS int
95 cullFrustum (double planes[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb);
96
97 PCL_EXPORTS float
98 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);
99
100 /** \brief Set of rendering properties. */
102 {
103 PCL_VISUALIZER_POINT_SIZE, /**< integer starting from 1 */
104 PCL_VISUALIZER_OPACITY, /**< Float going from 0.0 (transparent) to 1.0 (opaque) */
105 PCL_VISUALIZER_LINE_WIDTH, /**< Integer starting from 1 */
107 PCL_VISUALIZER_COLOR, /**< 3 floats (R, G, B) going from 0.0 (dark) to 1.0 (light) */
111 PCL_VISUALIZER_LUT, /**< colormap type \ref pcl::visualization::LookUpTableRepresentationProperties */
112 PCL_VISUALIZER_LUT_RANGE /**< two doubles (min and max) or ::PCL_VISUALIZER_LUT_RANGE_AUTO */
113 };
114
121
128
129 /*! Colormap properties. See [mathworks colormap page](http://www.mathworks.com/help/matlab/ref/colormap.html#input_argument_name) for image representations of the colormaps. */
131 {
132 PCL_VISUALIZER_LUT_JET, /**< Jet colormap */
133 PCL_VISUALIZER_LUT_JET_INVERSE, /**< Inverse jet colormap */
134 PCL_VISUALIZER_LUT_HSV, /**< HSV colormap */
135 PCL_VISUALIZER_LUT_HSV_INVERSE, /**< Inverse HSV colormap */
136 PCL_VISUALIZER_LUT_GREY, /**< Grey colormap (black to white) */
137 PCL_VISUALIZER_LUT_BLUE2RED, /**< Blue to red colormap (blue to white to red) */
138 PCL_VISUALIZER_LUT_RANGE_AUTO, /**< Set LUT range to min and max values of the data */
139 PCL_VISUALIZER_LUT_VIRIDIS /**< Viridis colormap */
140 };
141
142 /** \brief Generate a lookup table for a colormap.
143 * \param[in] colormap_type
144 * \param[out] table a vtk lookup table
145 * \note The list of available colormaps can be found in \ref pcl::visualization::LookUpTableRepresentationProperties.
146 */
147 PCL_EXPORTS bool
149
150 //////////////////////////////////////////////////////////////////////////////////////////////
151 /** \brief Camera class holds a set of camera parameters together with the window pos/size. */
152 class PCL_EXPORTS Camera
153 {
154 public:
155 /** Construct a camera with meaningful default values.
156 * The camera is positioned at origin, looks along z-axis and has up-vector along y-axis. Window position and
157 * size are initialized with (0, 0) and (1, 1) respectively. */
159
160 /** Construct a camera by copying parameters from a VTK camera.
161 * Window position and size are initialized with (0, 0) and (1, 1) respectively.*/
162 Camera (vtkCamera& camera);
163
164 /** Construct a camera by copying parameters from a VTK camera and a VTK render window. */
165 Camera (vtkCamera& camera, vtkRenderWindow& window);
166
167 /** \brief Focal point or lookAt.
168 * \note The view direction can be obtained by (focal-pos).normalized ()
169 */
170 double focal[3];
171
172 /** \brief Position of the camera. */
173 double pos[3];
174
175 /** \brief Up vector of the camera.
176 * \note Not to be confused with the view direction, bad naming here. */
177 double view[3];
178
179 /** \brief Clipping planes depths.
180 * clip[0] is near clipping plane, and clip [1] is the far clipping plane
181 */
182 double clip[2];
183
184 /** \brief Field of view angle in y direction (radians). */
185 double fovy;
186
187 // the following variables are the actual position and size of the window on the screen and NOT the viewport!
188 // except for the size, which is the same the viewport is assumed to be centered and same size as the window.
189 double window_size[2];
190 double window_pos[2];
191
192
193 /** \brief Computes View matrix for Camera (Based on gluLookAt)
194 * \param[out] view_mat the resultant matrix
195 */
196 void
197 computeViewMatrix (Eigen::Matrix4d& view_mat) const;
198
199 /** \brief Computes Projection Matrix for Camera
200 * \param[out] proj the resultant matrix
201 */
202 void
203 computeProjectionMatrix (Eigen::Matrix4d& proj) const;
204
205 /**
206 * \brief Converts point to window coordinates
207 * \param[in] pt xyz point to be converted
208 * \param[out] window_cord vector containing the pts' window X,Y, Z and 1
209 * \note This function computes the projection and view matrix every time.
210 * It is very inefficient to use this for every point in the point cloud!
211 */
212 template<typename PointT> void
213 cvtWindowCoordinates (const PointT& pt, Eigen::Vector4d& window_cord) const;
214
215 /**
216 * \brief Converts point to window coordinates
217 * \param[in] pt xyz point to be converted
218 * \param[out] window_cord vector containing the pts' window X,Y, Z and 1
219 * \param[in] composite_mat composite transformation matrix (proj*view)
220 *
221 * \note Use this function to compute window coordinates with a pre-computed transformation function.
222 * The typical composite matrix will be the projection matrix * the view matrix. However, additional matrices like
223 * a camera distortion matrix can also be added.
224 */
225 template<typename PointT> void
226 cvtWindowCoordinates (const PointT& pt, Eigen::Vector4d& window_cord, const Eigen::Matrix4d& composite_mat) const;
227 };
228 }
229}
230
231#include <pcl/visualization/common/impl/common.hpp>
Camera class holds a set of camera parameters together with the window pos/size.
Definition common.h:153
Camera(vtkCamera &camera, vtkRenderWindow &window)
Construct a camera by copying parameters from a VTK camera and a VTK render window.
Camera(vtkCamera &camera)
Construct a camera by copying parameters from a VTK camera.
void computeViewMatrix(Eigen::Matrix4d &view_mat) const
Computes View matrix for Camera (Based on gluLookAt)
double fovy
Field of view angle in y direction (radians).
Definition common.h:185
Camera()
Construct a camera with meaningful default values.
void computeProjectionMatrix(Eigen::Matrix4d &proj) const
Computes Projection Matrix for Camera.
PCL_EXPORTS Eigen::Vector2i worldToView(const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height)
RenderingProperties
Set of rendering properties.
Definition common.h:102
@ PCL_VISUALIZER_COLOR
3 floats (R, G, B) going from 0.0 (dark) to 1.0 (light)
Definition common.h:107
@ PCL_VISUALIZER_LUT_RANGE
two doubles (min and max) or PCL_VISUALIZER_LUT_RANGE_AUTO
Definition common.h:112
@ PCL_VISUALIZER_REPRESENTATION
Definition common.h:108
@ PCL_VISUALIZER_OPACITY
Float going from 0.0 (transparent) to 1.0 (opaque)
Definition common.h:104
@ PCL_VISUALIZER_POINT_SIZE
integer starting from 1
Definition common.h:103
@ PCL_VISUALIZER_IMMEDIATE_RENDERING
Definition common.h:109
@ PCL_VISUALIZER_LUT
colormap type pcl::visualization::LookUpTableRepresentationProperties
Definition common.h:111
@ PCL_VISUALIZER_LINE_WIDTH
Integer starting from 1.
Definition common.h:105
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.
RenderingRepresentationProperties
Definition common.h:116
@ PCL_VISUALIZER_REPRESENTATION_SURFACE
Definition common.h:119
@ PCL_VISUALIZER_REPRESENTATION_POINTS
Definition common.h:117
@ PCL_VISUALIZER_REPRESENTATION_WIREFRAME
Definition common.h:118
PCL_EXPORTS void getViewFrustum(const Eigen::Matrix4d &view_projection_matrix, double planes[24])
LookUpTableRepresentationProperties
Definition common.h:131
@ PCL_VISUALIZER_LUT_GREY
Grey colormap (black to white)
Definition common.h:136
@ PCL_VISUALIZER_LUT_HSV_INVERSE
Inverse HSV colormap.
Definition common.h:135
@ PCL_VISUALIZER_LUT_RANGE_AUTO
Set LUT range to min and max values of the data.
Definition common.h:138
@ PCL_VISUALIZER_LUT_VIRIDIS
Viridis colormap.
Definition common.h:139
@ PCL_VISUALIZER_LUT_BLUE2RED
Blue to red colormap (blue to white to red)
Definition common.h:137
@ PCL_VISUALIZER_LUT_HSV
HSV colormap.
Definition common.h:134
@ PCL_VISUALIZER_LUT_JET
Jet colormap.
Definition common.h:132
@ PCL_VISUALIZER_LUT_JET_INVERSE
Inverse jet colormap.
Definition common.h:133
ShadingRepresentationProperties
Definition common.h:123
@ PCL_VISUALIZER_SHADING_GOURAUD
Definition common.h:125
@ PCL_VISUALIZER_SHADING_PHONG
Definition common.h:126
@ PCL_VISUALIZER_SHADING_FLAT
Definition common.h:124
PCL_EXPORTS bool getColormapLUT(LookUpTableRepresentationProperties colormap_type, vtkSmartPointer< vtkLookupTable > &table)
Generate a lookup table for a colormap.
PCL_EXPORTS Eigen::Matrix4d vtkToEigen(vtkMatrix4x4 *vtk_matrix)
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)
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.
A point structure representing Euclidean xyz coordinates, and the RGB color.
A structure representing RGB color information.