Point Cloud Library (PCL) 1.12.0
Loading...
Searching...
No Matches
colors.h
1/*
2 * Software License Agreement (BSD License)
3 *
4 * Point Cloud Library (PCL) - www.pointclouds.org
5 * Copyright (c) 2014-, Open Perception, Inc.
6 *
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * * Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer in the documentation and/or other materials provided
18 * with the distribution.
19 * * Neither the name of the copyright holder(s) nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 *
36 */
37
38#pragma once
39
40#include <pcl/pcl_macros.h>
41#include <pcl/point_types.h>
42
43#include <type_traits> // for is_floating_point
44#include <array> // for std::array especially in Clang Darwin and MSVC
45
46namespace pcl
47{
48
49 PCL_EXPORTS RGB
50 getRandomColor (double min = 0.2, double max = 2.8);
51
53 {
54 /** Color lookup table consisting of 256 colors structured in a maximally
55 * discontinuous manner. Generated using the method of Glasbey et al.
56 * (see https://github.com/taketwo/glasbey) */
58 /** A perceptually uniform colormap created by Stéfan van der Walt and
59 * Nathaniel Smith for the Python matplotlib library.
60 * (see https://youtu.be/xAoljeRJ3lU for background and overview) */
62 };
63
64 template <ColorLUTName T>
66 {
67
68 public:
69
70 /** Get a color from the lookup table with a given id.
71 *
72 * The id should be less than the size of the LUT (see size()). */
73 static RGB at (std::size_t color_id);
74
75 /** Get the number of colors in the lookup table.
76 *
77 * Note: the number of colors is different from the number of elements
78 * in the lookup table (each color is defined by three bytes). */
79 static std::size_t size ();
80
81 /** Get a raw pointer to the lookup table. */
82 static const unsigned char* data ();
83
84 };
85
88
89 /**
90 * @brief Returns a Look-Up Table useful in converting RGB to sRGB
91 * @tparam T floating point type with resultant value
92 * @tparam bits depth of RGB
93 * @return 1-D LUT for converting R, G or B into Rs, Gs or Bs
94 * @remarks sRGB was proposed by Stokes et al. as a uniform default color
95 * space for the internet
96 * M. Stokes, M. Anderson, S. Chandrasekar, and R. Motta: A standard default colorspace for the internet - sRGB (Nov 1996)
97 * IEC 61966-2.1 Default RGB Colour Space - sRGB (International Electrotechnical Commission, Geneva, Switzerland, 1999)
98 * www.srgb.com, www.color.org/srgb.html
99 */
100 template <typename T, std::uint8_t bits = 8>
101 PCL_EXPORTS inline std::array<T, 1 << bits>
102 RGB2sRGB_LUT() noexcept
103 {
104 static_assert(std::is_floating_point<T>::value, "LUT value must be a floating point");
105
106 constexpr const std::size_t size = 1 << bits;
107
108 static const auto sRGB_LUT = [&]() {
109 // MSVC wouldn't take `size` here instead of the expression
110 std::array<T, 1 << bits> LUT;
111 for (std::size_t i = 0; i < size; ++i) {
112 T f = static_cast<T>(i) / static_cast<T>(size - 1);
113 if (f > 0.04045) {
114 // ((f + 0.055)/1.055)^2.4
115 LUT[i] = static_cast<T>(
116 std::pow((f + static_cast<T>(0.055)) / static_cast<T>(1.055),
117 static_cast<T>(2.4)));
118 }
119 else {
120 // f / 12.92
121 LUT[i] = f / static_cast<T>(12.92);
122 }
123 }
124 return LUT;
125 }();
126 return sRGB_LUT;
127 }
128
129 /**
130 * @brief Returns a Look-Up Table useful in converting scaled CIE XYZ into CIE L*a*b*
131 * @details The function assumes that the XYZ values are
132 * * not normalized using reference illuminant
133 * * scaled such that reference illuminant has Xn = Yn = Zn = discretizations
134 * @tparam T floating point type with resultant value
135 * @tparam discretizations number of levels for the LUT
136 * @return 1-D LUT with results of f(X/Xn)
137 * @note This function doesn't convert from CIE XYZ to CIE L*a*b*. The actual conversion
138 * is as follows:
139 * L* = 116 * [f(Y/Yn) - 16/116]
140 * a* = 500 * [f(X/Xn) - f(Y/Yn)]
141 * b* = 200 * [f(Y/Yn) - f(Z/Zn)]
142 * Where, Xn, Yn and Zn are values of the reference illuminant (at prescribed angle)
143 * f is appropriate function such that L* = 100, a* = b* = 0 for white color
144 * Reference: Billmeyer and Saltzman’s Principles of Color Technology
145 */
146 template <typename T, std::size_t discretizations = 4000>
147 PCL_EXPORTS inline const std::array<T, discretizations>&
148 XYZ2LAB_LUT() noexcept
149 {
150 static_assert(std::is_floating_point<T>::value, "LUT value must be a floating point");
151
152 static const auto f_LUT = [&]() {
153 std::array<T, discretizations> LUT;
154 for (std::size_t i = 0; i < discretizations; ++i) {
155 T f = static_cast<T>(i) / static_cast<T>(discretizations);
156 if (f > static_cast<T>(0.008856)) {
157 // f^(1/3)
158 LUT[i] = static_cast<T>(std::pow(f, (static_cast<T>(1) / static_cast<T>(3))));
159 }
160 else {
161 // 7.87 * f + 16/116
162 LUT[i] =
163 static_cast<T>(7.87) * f + (static_cast<T>(16) / static_cast<T>(116));
164 }
165 }
166 return LUT;
167 }();
168 return f_LUT;
169 }
170} // namespace pcl
static std::size_t size()
Get the number of colors in the lookup table.
static RGB at(std::size_t color_id)
Get a color from the lookup table with a given id.
static const unsigned char * data()
Get a raw pointer to the lookup table.
Defines all the PCL implemented PointT point type structures.
PCL_EXPORTS const std::array< T, discretizations > & XYZ2LAB_LUT() noexcept
Returns a Look-Up Table useful in converting scaled CIE XYZ into CIE L*a*b*.
Definition colors.h:148
PCL_EXPORTS RGB getRandomColor(double min=0.2, double max=2.8)
ColorLUTName
Definition colors.h:53
@ LUT_GLASBEY
Color lookup table consisting of 256 colors structured in a maximally discontinuous manner.
Definition colors.h:57
@ LUT_VIRIDIS
A perceptually uniform colormap created by Stéfan van der Walt and Nathaniel Smith for the Python mat...
Definition colors.h:61
PCL_EXPORTS std::array< T, 1<< bits > RGB2sRGB_LUT() noexcept
Returns a Look-Up Table useful in converting RGB to sRGB.
Definition colors.h:102
Defines all the PCL and non-PCL macros used.
A structure representing RGB color information.