1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #ifndef _BGFX_COLOR_BCOLOR_HXX 25 #define _BGFX_COLOR_BCOLOR_HXX 26 27 #include <basegfx/tuple/b3dtuple.hxx> 28 #include <com/sun/star/uno/Reference.hxx> 29 #include <com/sun/star/uno/Sequence.hxx> 30 #include <vector> 31 32 ////////////////////////////////////////////////////////////////////////////// 33 // predeclarations 34 35 namespace com { namespace sun { namespace star { namespace rendering { 36 class XGraphicDevice; 37 }}}} 38 39 ////////////////////////////////////////////////////////////////////////////// 40 41 namespace basegfx 42 { 43 /** Base Color class with three double values 44 45 This class derives all operators and common handling for 46 a 3D data class from B3DTuple. All necessary extensions 47 which are special for colors will be added here. 48 49 @see B3DTuple 50 */ 51 class BColor : public B3DTuple 52 { 53 public: 54 /** Create a Color with red, green and blue components from [0.0 to 1.0] 55 56 The color is initialized to (0.0, 0.0, 0.0) 57 */ 58 BColor() 59 : B3DTuple() 60 {} 61 62 /** Create a 3D Color 63 64 @param fRed 65 @param fGreen 66 @param fBlue 67 These parameters are used to initialize the red, green and blue intensities of the color 68 */ 69 BColor(double fRed, double fGreen, double fBlue) 70 : B3DTuple(fRed, fGreen, fBlue) 71 {} 72 73 /** Create a 3D Color 74 75 @param fLuminosity 76 The parameter is used to initialize the red, green and blue intensities of the color 77 */ 78 BColor(double fLuminosity) 79 : B3DTuple(fLuminosity, fLuminosity, fLuminosity) 80 {} 81 82 /** Create a copy of a Color 83 84 @param rVec 85 The Color which will be copied. 86 */ 87 BColor(const BColor& rVec) 88 : B3DTuple(rVec) 89 {} 90 91 /** constructor with tuple to allow copy-constructing 92 from B3DTuple-based classes 93 */ 94 BColor(const ::basegfx::B3DTuple& rTuple) 95 : B3DTuple(rTuple) 96 {} 97 98 ~BColor() 99 {} 100 101 // data access read 102 double getRed() const { return mfX; } 103 double getGreen() const { return mfY; } 104 double getBlue() const { return mfZ; } 105 106 // data access write 107 void setRed(double fNew) { mfX = fNew; } 108 void setGreen(double fNew) { mfY = fNew; } 109 void setBlue(double fNew) { mfZ = fNew; } 110 111 /** *=operator to allow usage from BColor, too 112 */ 113 BColor& operator*=( const BColor& rPnt ) 114 { 115 mfX *= rPnt.mfX; 116 mfY *= rPnt.mfY; 117 mfZ *= rPnt.mfZ; 118 return *this; 119 } 120 121 /** *=operator to allow usage from BColor, too 122 */ 123 BColor& operator*=(double t) 124 { 125 mfX *= t; 126 mfY *= t; 127 mfZ *= t; 128 return *this; 129 } 130 131 /** assignment operator to allow assigning the results 132 of B3DTuple calculations 133 */ 134 BColor& operator=( const ::basegfx::B3DTuple& rVec ) 135 { 136 mfX = rVec.getX(); 137 mfY = rVec.getY(); 138 mfZ = rVec.getZ(); 139 return *this; 140 } 141 142 // blend to another color using luminance 143 void blend(const BColor& rColor) 144 { 145 const double fLuminance(luminance()); 146 mfX = rColor.getRed() * fLuminance; 147 mfY = rColor.getGreen() * fLuminance; 148 mfZ = rColor.getBlue() * fLuminance; 149 } 150 151 // luminance 152 double luminance() const 153 { 154 const double fRedWeight(77.0 / 256.0); // 0.30 155 const double fGreenWeight(151.0 / 256.0); // 0.59 156 const double fBlueWeight(28.0 / 256.0); // 0.11 157 158 return (mfX * fRedWeight + mfY * fGreenWeight + mfZ * fBlueWeight); 159 } 160 161 // distances in color space 162 double getDistanceRed(const BColor& rColor) const { return (getRed() > rColor.getRed() ? getRed() - rColor.getRed() : rColor.getRed() - getRed()); } 163 double getDistanceGreen(const BColor& rColor) const { return (getGreen() > rColor.getGreen() ? getGreen() - rColor.getGreen() : rColor.getGreen() - getGreen()); } 164 double getDistanceBlue(const BColor& rColor) const { return (getBlue() > rColor.getBlue() ? getBlue() - rColor.getBlue() : rColor.getBlue() - getBlue()); } 165 166 double getDistance(const BColor& rColor) const 167 { 168 const double fDistR(getDistanceRed(rColor)); 169 const double fDistG(getDistanceGreen(rColor)); 170 const double fDistB(getDistanceBlue(rColor)); 171 172 return sqrt(fDistR * fDistR + fDistG * fDistG + fDistB * fDistB); 173 } 174 175 double getMinimumDistance(const BColor& rColor) const 176 { 177 const double fDistR(getDistanceRed(rColor)); 178 const double fDistG(getDistanceGreen(rColor)); 179 const double fDistB(getDistanceBlue(rColor)); 180 181 double fRetval(fDistR < fDistG ? fDistR : fDistG); 182 return (fRetval < fDistB ? fRetval : fDistB); 183 } 184 185 double getMaximumDistance(const BColor& rColor) const 186 { 187 const double fDistR(getDistanceRed(rColor)); 188 const double fDistG(getDistanceGreen(rColor)); 189 const double fDistB(getDistanceBlue(rColor)); 190 191 double fRetval(fDistR > fDistG ? fDistR : fDistG); 192 return (fRetval > fDistB ? fRetval : fDistB); 193 } 194 195 // clamp color to [0.0..1.0] values in all three intensity components 196 BColor& clamp() 197 { 198 mfX = basegfx::clamp(mfX, 0.0, 1.0); 199 mfY = basegfx::clamp(mfY, 0.0, 1.0); 200 mfZ = basegfx::clamp(mfZ, 0.0, 1.0); 201 return *this; 202 } 203 204 BColor& invert() 205 { 206 mfX = 1.0 - mfX; 207 mfY = 1.0 - mfY; 208 mfZ = 1.0 - mfZ; 209 return *this; 210 } 211 212 static const BColor& getEmptyBColor() 213 { 214 return (const BColor&) ::basegfx::B3DTuple::getEmptyTuple(); 215 } 216 217 com::sun::star::uno::Sequence< double > colorToDoubleSequence(const com::sun::star::uno::Reference< com::sun::star::rendering::XGraphicDevice >& /*xGraphicDevice*/) const 218 { 219 com::sun::star::uno::Sequence< double > aRet(4); 220 double* pRet = aRet.getArray(); 221 222 pRet[0] = mfX; 223 pRet[1] = mfY; 224 pRet[2] = mfZ; 225 pRet[3] = 1.0; 226 227 return aRet; 228 } 229 }; 230 } // end of namespace basegfx 231 232 #endif /* _BGFX_COLOR_BCOLOR_HXX */ 233 234 ////////////////////////////////////////////////////////////////////////////// 235 // eof 236