|
eLynx SDK
v3.3.0 C++ image processing API reference |
00001 //============================================================================ 00002 // PixelBase.h Image.Component package 00003 //============================================================================ 00004 // Usage : define common functionality for different types of pixels 00005 //---------------------------------------------------------------------------- 00006 // Copyright (C) 2006 by eLynx project 00007 // 00008 // This library is free software; you can redistribute it and/or 00009 // modify it under the terms of the GNU Library General Public 00010 // License as published by the Free Software Foundation; either 00011 // version 2 of the License, or (at your option) any later version. 00012 // 00013 // This library is distributed in the hope that it will be useful, 00014 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00016 // See the GNU Library General Public License for more details. 00017 //---------------------------------------------------------------------------- 00018 #ifndef __PixelBase_h__ 00019 #define __PixelBase_h__ 00020 00021 #include <elx/core/CoreTypes.h> 00022 #include <elx/math/MathCore.h> 00023 00024 namespace eLynx { 00025 namespace Image { 00026 00028 enum { PC_MAX=4 }; 00029 00030 template<typename T> 00031 struct ExportedByImage SampleTypeTraits 00032 { 00033 static const T _black; 00034 static const T _white; 00035 }; 00036 00037 00040 00041 template <class Pixel> 00042 struct PixelBase 00043 { 00046 Pixel Add(const Pixel& iOther) const; 00047 Pixel AddClamp(const Pixel& iOther) const; 00048 Pixel Add(const Pixel& iOther, uint32 iChannelMask) const; 00049 Pixel AddClamp(const Pixel& iOther, uint32 iChannelMask) const; 00050 Pixel& AddSelf(const Pixel& iOther); 00051 Pixel& AddClampSelf(const Pixel& iOther); 00052 template <typename U> Pixel Add(const U iValue) const; 00053 template <typename U> Pixel AddClamp(const U iValue) const; 00054 template <typename U> Pixel Add(const U iValue, uint32 iChannelMask) const; 00055 template <typename U> Pixel AddClamp(const U iValue, uint32 iChannelMask) const; 00056 template <typename U> Pixel& AddSelf(const U iValue); 00057 template <typename U> Pixel& AddClampSelf(const U iValue); 00059 00062 Pixel Sub(const Pixel& iOther) const; 00063 Pixel SubClamp(const Pixel& iOther) const; 00064 Pixel Sub(const Pixel& iOther, uint32 iChannelMask) const; 00065 Pixel SubClamp(const Pixel& iOther, uint32 iChannelMask) const; 00066 Pixel SubAbsClamp(const Pixel& iOther) const; 00067 Pixel SubAbsClamp(const Pixel& iOther, uint32 iChannelMask) const; 00068 Pixel& SubSelf(const Pixel& iOther); 00069 Pixel& SubClampSelf(const Pixel& iOther); 00070 template <typename U> Pixel Sub(const U iValue) const; 00071 template <typename U> Pixel SubClamp(const U iValue) const; 00072 template <typename U> Pixel Sub(const U iValue, uint32 iChannelMask) const; 00073 template <typename U> Pixel SubClamp(const U iValue, uint32 iChannelMask) const; 00074 template <typename U> Pixel& SubSelf(const U iValue); 00075 template <typename U> Pixel& SubClampSelf(const U iValue); 00077 00080 Pixel Mul(const Pixel& iOther) const; 00081 Pixel MulClamp(const Pixel& iOther) const; 00082 Pixel Mul(const Pixel& iOther, uint32 iChannelMask) const; 00083 Pixel MulClamp(const Pixel& iOther, uint32 iChannelMask) const; 00084 Pixel& MulSelf(const Pixel& iOther); 00085 Pixel& MulClampSelf(const Pixel& iOther); 00086 template <typename U> Pixel Mul(const U iValue) const; 00087 template <typename U> Pixel MulClamp(const U iValue) const; 00088 template <typename U> Pixel Mul(const U iValue, uint32 iChannelMask) const; 00089 template <typename U> Pixel MulClamp(const U iValue, uint32 iChannelMask) const; 00090 template <typename U> Pixel& MulSelf(const U iValue); 00091 template <typename U> Pixel& MulClampSelf(const U iValue); 00093 00096 00097 Pixel Div(const Pixel& iOther, FloatType) const; 00098 Pixel Div(const Pixel& iOther, IntegerType) const; 00099 Pixel Div(const Pixel& iOther, FloatType, uint32 iChannelMask) const; 00100 Pixel Div(const Pixel& iOther, IntegerType, uint32 iChannelMask) const; 00101 Pixel& DivSelf(const Pixel& iOther, FloatType); 00102 Pixel& DivSelf(const Pixel& iOther, IntegerType); 00103 00104 template <typename U> Pixel Div(const U iValue, FloatType) const; 00105 template <typename U> Pixel Div(const U iValue, IntegerType) const; 00106 template <typename U> Pixel Div(const U iValue, FloatType, uint32 iChannelMask) const; 00107 template <typename U> Pixel Div(const U iValue, IntegerType, uint32 iChannelMask) const; 00108 template <typename U> Pixel& DivSelf(const U iValue, FloatType); 00109 template <typename U> Pixel& DivSelf(const U iValue, IntegerType); 00111 00112 00115 00116 bool Equal(const Pixel& iOther) const; 00117 00119 00122 00123 template <typename U> 00124 Pixel& PowSelf(const U& iValue, FloatType); 00125 00126 template <typename U> 00127 Pixel& PowSelf(const U& iValue, IntegerType); 00128 00129 template <typename U> 00130 Pixel& PowSelf(const U& iValue); 00131 00132 Pixel& PowSelf(const Pixel& iOther, FloatType); 00133 Pixel& PowSelf(const Pixel& iOther, IntegerType); 00134 00135 Pixel& ExpSelf(FloatType); 00136 Pixel& ExpSelf(IntegerType); 00137 00138 Pixel& LogSelf(FloatType); 00139 Pixel& LogSelf(IntegerType); 00140 00141 Pixel& Log10Self(FloatType); 00142 Pixel& Log10Self(IntegerType); 00143 00144 Pixel& SqrtSelf(FloatType); 00145 Pixel& SqrtSelf(IntegerType); 00146 00147 template <typename U> 00148 Pixel Pow(const U& iValue, FloatType) const; 00149 00150 template <typename U> 00151 Pixel Pow(const U& iValue, IntegerType) const; 00152 00153 Pixel Pow(const Pixel& iOther, FloatType) const; 00154 Pixel Pow(const Pixel& iOther, IntegerType) const; 00155 00156 Pixel Exp(FloatType) const; 00157 Pixel Exp(IntegerType) const; 00158 00159 Pixel Log(FloatType) const; 00160 Pixel Log(IntegerType) const; 00161 00162 Pixel Log10(FloatType) const; 00163 Pixel Log10(IntegerType) const; 00164 00165 Pixel Sqrt(FloatType) const; 00166 Pixel Sqrt(IntegerType) const; 00168 00169 }; 00170 00171 //---------------------------------------------------------------------------- 00172 #define PIXEL_INTEGER_TYPE \ 00173 (IntegerToType< ResolutionTypeTraits< typename Pixel::type >::_bInteger >()) 00174 00175 #define PIXEL_LUT_TYPE \ 00176 (LutToType< ResolutionTypeTraits< typename Pixel::type >::_bLUT >()) 00177 00178 //---------------------------------------------------------------------------- 00180 //---------------------------------------------------------------------------- 00181 template<bool B> 00182 struct ColorToType{ enum {_Type = B}; }; 00183 00184 typedef ColorToType<true> ColorType; 00185 typedef ColorToType<false> NonColorType; 00186 00187 #define PIXEL_COLOR_TYPE(_PIXEL_) (ColorToType< _PIXEL_::_bColor >()) 00188 00189 //---------------------------------------------------------------------------- 00191 //---------------------------------------------------------------------------- 00192 template<bool B> 00193 struct GreyToType{ enum {_Type = B}; }; 00194 00195 typedef GreyToType<true> GreyType; 00196 typedef GreyToType<false> NonGreyType; 00197 00198 #define PIXEL_GREY_TYPE(_PIXEL_) (GreyToType< _PIXEL_::_bGrey >()) 00199 00200 //---------------------------------------------------------------------------- 00202 //---------------------------------------------------------------------------- 00203 template<bool B> 00204 struct AlphaToType{ enum {_Type = B}; }; 00205 00206 typedef AlphaToType<true> AlphaType; 00207 typedef AlphaToType<false> NonAlphaType; 00208 00209 #define PIXEL_ALPHA_TYPE(_PIXEL_) (AlphaToType< _PIXEL_::_bHasAlpha >()) 00210 00211 //---------------------------------------------------------------------------- 00212 inline bool elxUseChannel(uint32 iChannel, uint32 iChannelMask) 00213 { 00214 return (0 != ((1 << iChannel) & iChannelMask)); 00215 } 00216 00217 } // namespace Image 00218 } // namespace eLynx 00219 00220 //---------------------------------------------------------------------------- 00221 // clamp 00222 //---------------------------------------------------------------------------- 00223 namespace eLynx { 00224 namespace Image { 00227 00228 template <class Pixel, typename U> 00229 void elxClampChannel(Pixel& ioPixel, const uint32 iChannel, U iValue); 00230 00231 00232 template <typename In, typename Out, template <typename> class Pixel> 00233 void elxPixelClamp(const PixelBase<Pixel<In> >& iPixelIn, PixelBase<Pixel<Out> >& oPixelOut); 00234 00235 template <typename In, typename Out, template <typename> class Pixel> 00236 void elxPixelClamp(const PixelBase<Pixel<In> >& iPixelIn, PixelBase<Pixel<Out> >& oPixelOut, FloatType); 00237 00238 template <typename In, typename Out, template <typename> class Pixel> 00239 void elxPixelClamp(const PixelBase<Pixel<In> >& iPixelIn, PixelBase<Pixel<Out> >& oPixelOut, IntegerType); 00240 00241 00242 template <typename In, typename Out, template <typename> class Pixel> 00243 void elxPixelClamp(const PixelBase<Pixel<In> >& iPixelIn, PixelBase<Pixel<Out> >& oPixelOut, uint32 iChannelMask); 00244 00245 template <typename In, typename Out, template <typename> class Pixel> 00246 void elxPixelClamp(const PixelBase< Pixel<In> >& iPixelIn, PixelBase< Pixel<Out> >& oPixelOut, FloatType, uint32 iChannelMask); 00247 00248 template <typename In, typename Out, template <typename> class Pixel> 00249 void elxPixelClamp(const PixelBase<Pixel<In> >& iPixelIn, PixelBase<Pixel<Out> >& oPixelOut, IntegerType, uint32 iChannelMask); 00250 00252 } // namespace Image 00253 } // namespace eLynx 00254 00255 #include "inl/Pixel/Clamp.inl" 00256 00257 00258 //---------------------------------------------------------------------------- 00259 // addition 00260 //---------------------------------------------------------------------------- 00261 namespace eLynx { 00262 namespace Image { 00265 00266 template <class Pixel> 00267 Pixel operator+ (const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00268 00269 template <class Pixel> 00270 Pixel operator+ (const PixelBase<Pixel>& iPixel, const typename Pixel::type iValue); 00271 00272 template <class Pixel> 00273 Pixel operator+ (const typename Pixel::type iValue, const PixelBase<Pixel>& iPixel); 00274 00275 template <class Pixel> 00276 Pixel& operator+= (PixelBase<Pixel>& ioFirst, const Pixel& iSecond); 00277 00278 template <class Pixel> 00279 Pixel& operator+= (PixelBase<Pixel>& ioPixel, const typename Pixel::type iValue); 00280 00281 00282 template <class Pixel> 00283 Pixel elxPixelAdd(const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00284 00285 template <class Pixel> 00286 Pixel elxPixelAdd(const PixelBase<Pixel>& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00287 00288 template <class Pixel, typename U> 00289 Pixel elxPixelAdd(const PixelBase<Pixel>& iPixel, const U& iValue); 00290 00291 template <class Pixel, typename U> 00292 Pixel elxPixelAdd(const PixelBase<Pixel>& iPixel, const U& iValue, uint32 iChannelMask); 00293 00294 template <class Pixel> 00295 Pixel elxPixelAddClamp(const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00296 00297 template <class Pixel> 00298 Pixel elxPixelAddClamp(const PixelBase<Pixel>& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00299 00300 template <class Pixel, typename U> 00301 Pixel elxPixelAddClamp(const PixelBase<Pixel>& iPixel, const U& iValue); 00302 00303 template <class Pixel, typename U> 00304 Pixel elxPixelAddClamp(const PixelBase<Pixel>& iPixel, const U& iValue, uint32 iChannelMask); 00305 00307 } // namespace Image 00308 } // namespace eLynx 00309 00310 #include "inl/Pixel/Add.inl" 00311 00312 00313 //---------------------------------------------------------------------------- 00314 // substration 00315 //---------------------------------------------------------------------------- 00316 namespace eLynx { 00317 namespace Image { 00320 template <class Pixel> 00321 Pixel operator- (const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00322 00323 template <class Pixel> 00324 Pixel operator- (const PixelBase<Pixel>& iPixel, const typename Pixel::type iValue); 00325 00326 template <class Pixel> 00327 Pixel operator- (const typename Pixel::type iValue, const PixelBase<Pixel>& iPixel); 00328 00329 template <class Pixel> 00330 Pixel& operator-= (PixelBase<Pixel>& ioFirst, const Pixel& iSecond); 00331 00332 template <class Pixel> 00333 Pixel& operator-= (PixelBase<Pixel>& ioPixel, const typename Pixel::type iValue); 00334 00335 00336 template <class Pixel> 00337 Pixel elxPixelSub(const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00338 00339 template <class Pixel> 00340 Pixel elxPixelSub(const PixelBase<Pixel>& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00341 00342 template <class Pixel, typename U> 00343 Pixel elxPixelSub(const PixelBase<Pixel>& iPixel, const U& iValue); 00344 00345 template <class Pixel, typename U> 00346 Pixel elxPixelSub(const PixelBase<Pixel>& iPixel, const U& iValue, uint32 iChannelMask); 00347 00348 template <class Pixel> 00349 Pixel elxPixelSubClamp(const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00350 00351 template <class Pixel> 00352 Pixel elxPixelSubClamp(const PixelBase<Pixel>& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00353 00354 template <class Pixel, typename U> 00355 Pixel elxPixelSubClamp(const PixelBase<Pixel>& iPixel, const U& iValue); 00356 00357 template <class Pixel, typename U> 00358 Pixel elxPixelSubClamp(const PixelBase<Pixel>& iPixel, const U& iValue, uint32 iChannelMask); 00359 00360 template <class Pixel> 00361 Pixel elxPixelSubAbsClamp(const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00362 00363 template <class Pixel> 00364 Pixel elxPixelSubAbsClamp(const PixelBase<Pixel>& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00365 00367 } // namespace Image 00368 } // namespace eLynx 00369 00370 #include "inl/Pixel/Sub.inl" 00371 00372 00373 //---------------------------------------------------------------------------- 00374 // multiplication 00375 //---------------------------------------------------------------------------- 00376 namespace eLynx { 00377 namespace Image { 00380 00381 template <class Pixel> 00382 Pixel operator* (const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00383 00384 template <class Pixel> 00385 Pixel operator* (const PixelBase<Pixel>& iPixel, const typename Pixel::type iValue); 00386 00387 template <class Pixel> 00388 Pixel operator* (const typename Pixel::type iValue, const PixelBase<Pixel>& iPixel); 00389 00390 template <class Pixel> 00391 Pixel& operator*= (PixelBase<Pixel>& ioFirst, const Pixel& iSecond); 00392 00393 template <class Pixel> 00394 Pixel& operator*= (PixelBase<Pixel>& ioPixel, const typename Pixel::type iValue); 00395 00396 00397 template <class Pixel> 00398 Pixel elxPixelMul(const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00399 00400 template <class Pixel> 00401 Pixel elxPixelMul(const PixelBase<Pixel>& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00402 00403 template <class Pixel, typename U> 00404 Pixel elxPixelMul(const PixelBase<Pixel>& iPixel, const U& iValue); 00405 00406 template <class Pixel, typename U> 00407 Pixel elxPixelMul(const PixelBase<Pixel>& iPixel, const U& iValue, uint32 iChannelMask); 00408 00409 template <class Pixel> 00410 Pixel elxPixelMulClamp(const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00411 00412 template <class Pixel> 00413 Pixel elxPixelMulClamp(const PixelBase<Pixel>& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00414 00416 } // namespace Image 00417 } // namespace eLynx 00418 00419 #include "inl/Pixel/Mul.inl" 00420 00421 00422 //---------------------------------------------------------------------------- 00423 // division 00424 //---------------------------------------------------------------------------- 00425 namespace eLynx { 00426 namespace Image { 00429 template <class Pixel> 00430 Pixel operator/ (const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00431 00432 template <class Pixel> 00433 Pixel operator/ (const PixelBase<Pixel>& iPixel, const typename Pixel::type iValue); 00434 00435 template <class Pixel> 00436 Pixel operator/ (const typename Pixel::type iValue, const PixelBase<Pixel>& iPixel); 00437 00438 template <class Pixel> 00439 Pixel& operator/= (PixelBase<Pixel>& ioFirst, const Pixel& iSecond); 00440 00441 template <class Pixel> 00442 Pixel& operator/= (PixelBase<Pixel>& ioPixel, const typename Pixel::type iValue); 00443 00444 00445 template <class Pixel> 00446 Pixel elxPixelDiv(const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00447 00448 template <class Pixel> 00449 Pixel elxPixelDiv(const PixelBase<Pixel>& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00450 00451 template <class Pixel, typename U> 00452 Pixel elxPixelDiv(const PixelBase<Pixel>& iPixel, const U& iValue); 00453 00454 template <class Pixel, typename U> 00455 Pixel elxPixelDiv(const PixelBase<Pixel>& iPixel, const U& iValue, uint32 iChannelMask); 00457 } // namespace Image 00458 } // namespace eLynx 00459 00460 #include "inl/Pixel/Div.inl" 00461 00462 00463 //---------------------------------------------------------------------------- 00464 // power 00465 //---------------------------------------------------------------------------- 00466 namespace eLynx { 00467 namespace Image { 00470 00471 template <class Pixel> 00472 Pixel& elxSqrtSelf(PixelBase<Pixel>& ioPixel); 00473 00474 template <typename U, class Pixel> 00475 Pixel& elxPowSelf(PixelBase<Pixel>& ioPixel, const U& iValue); 00476 00477 template <class Pixel> 00478 Pixel& elxPixelPowSelf(PixelBase<Pixel>& ioPixel1, const Pixel& iPixel2); 00479 00480 template <class Pixel> 00481 Pixel& elxPixelExpSelf(PixelBase<Pixel>& ioPixel); 00482 00483 template <class Pixel> 00484 Pixel& elxPixelLogSelf(PixelBase<Pixel>& ioPixel); 00485 00486 template <class Pixel> 00487 Pixel& elxPixelLog10Self(PixelBase<Pixel>& ioPixel); 00488 00489 template <class Pixel> 00490 Pixel& elxPixelSqrtSelf(PixelBase<Pixel>& ioPixel); 00491 00492 template <typename U, class Pixel> 00493 Pixel elxPixelPow(const PixelBase<Pixel>& iPixel, const U& iValue); 00494 00495 template <class Pixel> 00496 Pixel elxPixelPow(const PixelBase<Pixel>& iPixel1, const Pixel& iPixel2); 00497 00498 template <class Pixel> 00499 Pixel elxPixelExp(const PixelBase<Pixel>& iPixel); 00500 00501 template <class Pixel> 00502 Pixel elxPixelLog(const PixelBase<Pixel>& iPixel); 00503 00504 template <class Pixel> 00505 Pixel elxPixelLog10(const PixelBase<Pixel>& iPixel); 00506 00507 template <class Pixel> 00508 Pixel elxPixelSqrt(const PixelBase<Pixel>& iPixel); 00509 00511 } // namespace Image 00512 } // namespace eLynx 00513 00514 #include "inl/Pixel/Power.inl" 00515 00516 00517 //---------------------------------------------------------------------------- 00518 // equal 00519 //---------------------------------------------------------------------------- 00520 namespace eLynx { 00521 namespace Image { 00524 00525 template <class Pixel> 00526 bool operator == (const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00527 00528 template <class Pixel> 00529 bool operator != (const PixelBase<Pixel>& iFirst, const Pixel& iSecond); 00530 00531 template <class Pixel> 00532 bool elxPixelEqual(const Pixel& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00533 00535 } // namespace Image 00536 } // namespace eLynx 00537 00538 #include "inl/Pixel/Equal.inl" 00539 00540 00541 //---------------------------------------------------------------------------- 00542 // set 00543 //---------------------------------------------------------------------------- 00544 namespace eLynx { 00545 namespace Image { 00548 00549 template <class Pixel> 00550 void elxPixelSet(Pixel& ioPixel, double iValue); 00551 00552 template <class Pixel> 00553 void elxPixelSet(Pixel& ioPixel, double iValue, uint32 iChannelMask); 00554 00555 template <class Pixel> 00556 void elxPixelSet(Pixel& ioPixel, const Pixel& iPixel); 00557 00558 template <class Pixel> 00559 void elxPixelSet(Pixel& ioPixel, const Pixel& iPixel, uint32 iChannelMask); 00560 00562 } // namespace Image 00563 } // namespace eLynx 00564 00565 #include "inl/Pixel/Set.inl" 00566 00567 00568 //---------------------------------------------------------------------------- 00569 // abs 00570 //---------------------------------------------------------------------------- 00571 namespace eLynx { 00572 namespace Image { 00575 00576 template <class Pixel> 00577 Pixel elxPixelAbs(const Pixel& iPixel); 00578 00579 template <class Pixel> 00580 Pixel elxPixelAbs(const Pixel& iPixel, uint32 iChannelMask); 00581 00582 template <class Pixel, typename U> 00583 Pixel elxPixelAbsDiff(const Pixel& iPixel, const U& iValue); 00584 00585 template <class Pixel, typename U> 00586 Pixel elxPixelAbsDiff(const Pixel& iPixel, const U& iValue, uint32 iChannelMask); 00587 00588 template <class Pixel> 00589 Pixel elxPixelAbsDiff(const Pixel& iFirst, const Pixel& iSecond); 00590 00591 template <class Pixel> 00592 Pixel elxPixelAbsDiff(const Pixel& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00593 00595 } // namespace Image 00596 } // namespace eLynx 00597 00598 #include "inl/Pixel/Abs.inl" 00599 00600 00601 //---------------------------------------------------------------------------- 00602 // min 00603 //---------------------------------------------------------------------------- 00604 namespace eLynx { 00605 namespace Image { 00608 00609 template <class Pixel, typename U> 00610 Pixel elxPixelMin(const Pixel& iPixel, const U& iValue); 00611 00612 template <class Pixel, typename U> 00613 Pixel elxPixelMin(const Pixel& iPixel, const U& iValue, uint32 iChannelMask); 00614 00615 template <class Pixel> 00616 Pixel elxPixelMin(const Pixel& iFirst, const Pixel& iSecond); 00617 00618 template <class Pixel> 00619 Pixel elxPixelMin(const Pixel& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00620 00622 } // namespace Image 00623 } // namespace eLynx 00624 00625 #include "inl/Pixel/Min.inl" 00626 00627 00628 //---------------------------------------------------------------------------- 00629 // max 00630 //---------------------------------------------------------------------------- 00631 namespace eLynx { 00632 namespace Image { 00635 00636 template <class Pixel, typename U> 00637 Pixel elxPixelMax(const Pixel& iPixel, const U& iValue); 00638 00639 template <class Pixel, typename U> 00640 Pixel elxPixelMax(const Pixel& iPixel, const U& iValue, uint32 iChannelMask); 00641 00642 template <class Pixel> 00643 Pixel elxPixelMax(const Pixel& iFirst, const Pixel& iSecond); 00644 00645 template <class Pixel> 00646 Pixel elxPixelMax(const Pixel& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00647 00649 00650 } // namespace Image 00651 } // namespace eLynx 00652 00653 #include "inl/Pixel/Max.inl" 00654 00655 00656 //---------------------------------------------------------------------------- 00657 // mean 00658 //---------------------------------------------------------------------------- 00659 namespace eLynx { 00660 namespace Image { 00663 00664 template <class Pixel, typename U> 00665 Pixel elxPixelMean(const Pixel& iPixel, const U& iValue); 00666 00667 template <class Pixel, typename U> 00668 Pixel elxPixelMean(const Pixel& iPixel, const U& iValue, uint32 iChannelMask); 00669 00670 template <class Pixel> 00671 Pixel elxPixelMean(const Pixel& iFirst, const Pixel& iSecond); 00672 00673 template <class Pixel> 00674 Pixel elxPixelMean(const Pixel& iFirst, const Pixel& iSecond, uint32 iChannelMask); 00675 00677 00678 } // namespace Image 00679 } // namespace eLynx 00680 00681 #include "inl/Pixel/Mean.inl" 00682 00683 00684 //---------------------------------------------------------------------------- 00685 // blend 00686 //---------------------------------------------------------------------------- 00687 namespace eLynx { 00688 namespace Image { 00691 00692 template <class Pixel> 00693 Pixel elxPixelBlend(const Pixel& iPixel1, const Pixel& iPixel2, double iScalar); 00694 00695 template <class Pixel> 00696 Pixel elxPixelBlend(const Pixel& iPixel1, const Pixel& iPixel2, double iScalar, uint32 iChannelMask); 00697 00699 00700 } // namespace Image 00701 } // namespace eLynx 00702 00703 #include "inl/Pixel/Blend.inl" 00704 00705 00706 //---------------------------------------------------------------------------- 00707 // negation 00708 //---------------------------------------------------------------------------- 00709 namespace eLynx { 00710 namespace Image { 00713 00714 template <class Pixel> 00715 void elxPixelNegative(Pixel& ioPixel); 00716 00717 template <class Pixel> 00718 void elxPixelNegative(Pixel& ioPixel, uint32 iChannelMask); 00719 00721 00722 } // namespace Image 00723 } // namespace eLynx 00724 00725 #include "inl/Pixel/Neg.inl" 00726 00727 00728 //---------------------------------------------------------------------------- 00729 // Threshold 00730 //---------------------------------------------------------------------------- 00731 namespace eLynx { 00732 namespace Image { 00735 00736 template <class Pixel, typename U> 00737 Pixel elxPixelThreshold(const Pixel& iPixel, const U& iValue); 00738 00739 template <class Pixel, typename U> 00740 Pixel elxPixelThreshold(const Pixel& iPixel, const U& iValue, uint32 iChannelMask); 00742 00743 } // namespace Image 00744 } // namespace eLynx 00745 00746 #include "inl/Pixel/Threshold.inl" 00747 00748 #endif // __Pixels_h__