Visual Servoing Platform version 3.5.0
vpRGBa.cpp
1/****************************************************************************
2 *
3 * ViSP, open source Visual Servoing Platform software.
4 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5 *
6 * This software is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 * See the file LICENSE.txt at the root directory of this source
11 * distribution for additional information about the GNU GPL.
12 *
13 * For using ViSP with software that can not be combined with the GNU
14 * GPL, please contact Inria about acquiring a ViSP Professional
15 * Edition License.
16 *
17 * See http://visp.inria.fr for more information.
18 *
19 * This software was developed at:
20 * Inria Rennes - Bretagne Atlantique
21 * Campus Universitaire de Beaulieu
22 * 35042 Rennes Cedex
23 * France
24 *
25 * If you have questions regarding the use of this file, please contact
26 * Inria at visp@inria.fr
27 *
28 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30 *
31 * Description:
32 * RGBA pixel.
33 *
34 * Authors:
35 * Eric Marchand
36 * Fabien Spindler
37 *
38 *****************************************************************************/
39
46#include <visp3/core/vpColor.h>
47#include <visp3/core/vpDebug.h>
48#include <visp3/core/vpException.h>
49#include <visp3/core/vpRGBa.h>
50
56vpRGBa &vpRGBa::operator=(const unsigned char &v)
57{
58 this->R = v;
59 this->G = v;
60 this->B = v;
61 this->A = v;
62 return *this;
63}
64
69{
70 this->R = v.R;
71 this->G = v.G;
72 this->B = v.B;
73 this->A = v.A;
74 return *this;
75}
76
77#if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
82{
83 this->R = std::move(v.R);
84 this->G = std::move(v.G);
85 this->B = std::move(v.B);
86 this->A = std::move(v.A);
87 return *this;
88}
89#endif
90
101{
102 if (v.getRows() != 4) {
103 vpERROR_TRACE("Bad vector dimension ");
104 throw(vpException(vpException::dimensionError, "Bad vector dimension "));
105 }
106 R = (unsigned char)v[0];
107 G = (unsigned char)v[1];
108 B = (unsigned char)v[2];
109 A = (unsigned char)v[3];
110 return *this;
111}
112
119{
120 if (R != v.R)
121 return false;
122 if (G != v.G)
123 return false;
124 if (B != v.B)
125 return false;
126 if (A != v.A)
127 return false;
128
129 return true;
130}
136bool vpRGBa::operator!=(const vpRGBa &v) { return (R != v.R || G != v.G || B != v.B || A != v.A); }
137
144{
145 vpColVector n(4); // new color
146 n[0] = (double)R - (double)v.R;
147 n[1] = (double)G - (double)v.G;
148 n[2] = (double)B - (double)v.B;
149 n[3] = (double)A - (double)v.A;
150 return n;
151}
152
160{
161 vpRGBa n; // new color
162 n.R = static_cast<unsigned char>(R + v.R);
163 n.G = static_cast<unsigned char>(G + v.G);
164 n.B = static_cast<unsigned char>(B + v.B);
165 n.A = static_cast<unsigned char>(A + v.A);
166 return n;
167}
168
175{
176 vpColVector n(4); // new color
177 n[0] = R - v[0];
178 n[1] = G - v[1];
179 n[2] = B - v[2];
180 n[3] = A - v[3];
181 return n;
182}
183
190{
191 vpColVector n(4); // new color
192 n[0] = R + v[0];
193 n[1] = G + v[1];
194 n[2] = B + v[2];
195 n[3] = A + v[3];
196 return n;
197}
198
204vpColVector vpRGBa::operator*(const float &v) const
205{
206 vpColVector n(4);
207 n[0] = R * v;
208 n[1] = G * v;
209 n[2] = B * v;
210 n[3] = A * v;
211 return n;
212}
213
219vpColVector vpRGBa::operator*(const double &v) const
220{
221 vpColVector n(4);
222 n[0] = R * v;
223 n[1] = G * v;
224 n[2] = B * v;
225 n[3] = A * v;
226 return n;
227}
228
229bool vpRGBa::operator<(const vpRGBa &v) const
230{
231 double gray1 = 0.2126 * R + 0.7152 * G + 0.0722 * B;
232 double gray2 = 0.2126 * v.R + 0.7152 * v.G + 0.0722 * v.B;
233
234 return (gray1 < gray2);
235}
236
237bool vpRGBa::operator>(const vpRGBa &v) const
238{
239 double gray1 = 0.2126 * R + 0.7152 * G + 0.0722 * B;
240 double gray2 = 0.2126 * v.R + 0.7152 * v.G + 0.0722 * v.B;
241
242 return (gray1 > gray2);
243}
244
245vpRGBa operator*(const double &x, const vpRGBa &rgb) { return rgb * x; }
246
269VISP_EXPORT std::ostream &operator<<(std::ostream &os, const vpRGBa &rgba)
270{
271 os << "(" << (int)rgba.R << "," << (int)rgba.G << "," << (int)rgba.B << "," << (int)rgba.A << ")";
272 return os;
273}
friend std::ostream & operator<<(std::ostream &s, const vpArray2D< Type > &A)
Definition: vpArray2D.h:493
unsigned int getRows() const
Definition: vpArray2D.h:289
Implementation of column vector and the associated operations.
Definition: vpColVector.h:131
error that can be emited by ViSP classes.
Definition: vpException.h:72
@ dimensionError
Bad dimension.
Definition: vpException.h:95
VISP_EXPORT vpImagePoint operator*(const vpImagePoint &ip1, double scale)
Definition: vpRGBa.h:67
vpColVector operator-(const vpRGBa &v) const
Definition: vpRGBa.cpp:143
unsigned char B
Blue component.
Definition: vpRGBa.h:150
unsigned char R
Red component.
Definition: vpRGBa.h:148
bool operator<(const vpRGBa &v) const
Definition: vpRGBa.cpp:229
bool operator!=(const vpRGBa &v)
Definition: vpRGBa.cpp:136
vpRGBa & operator=(const unsigned char &v)
Definition: vpRGBa.cpp:56
vpRGBa operator+(const vpRGBa &v) const
Definition: vpRGBa.cpp:159
unsigned char G
Green component.
Definition: vpRGBa.h:149
unsigned char A
Additionnal component.
Definition: vpRGBa.h:151
bool operator>(const vpRGBa &v) const
Definition: vpRGBa.cpp:237
bool operator==(const vpRGBa &v)
Definition: vpRGBa.cpp:118
vpColVector operator*(const float &v) const
Definition: vpRGBa.cpp:204
#define vpERROR_TRACE
Definition: vpDebug.h:393