include/basebmp/colortraits.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_BASEBMP_COLORTRAITS_HXX
  21 #define INCLUDED_BASEBMP_COLORTRAITS_HXX
  22
  23 #include <basebmp/accessoradapters.hxx>
  24 #include <basebmp/metafunctions.hxx>
  25
  26 #include <vigra/mathutil.hxx>
  27
  28 namespace basebmp
  29 {
  30
  31 /** Functor template, to calculate alpha blending between two
  32     values. Float case.
  33
  34     @tpl polarity
  35     When true, 0 means fully transparent, and 1 fully opaque. And vice
  36     versa.
  37  */
  38 template< typename ValueType,
  39           typename AlphaType,
  40           bool     polarity > struct BlendFunctor;
  41 template< typename ValueType,
  42           typename AlphaType > struct BlendFunctor<ValueType,AlphaType,true>
  43   : public TernaryFunctorBase<AlphaType,ValueType,ValueType,ValueType>
  44 {
  45     ValueType operator()( AlphaType alpha,
  46                           ValueType v1,
  47                           ValueType v2 ) const
  48     {
  49         const typename vigra::NumericTraits<AlphaType>::RealPromote fAlpha(
  50             vigra::NumericTraits<AlphaType>::toRealPromote(alpha));
  51         return (vigra::NumericTraits<AlphaType>::one()-fAlpha)*v1 + fAlpha*v2;
  52     }
  53 };
  54 template< typename ValueType,
  55           typename AlphaType > struct BlendFunctor<ValueType,AlphaType,false>
  56   : public TernaryFunctorBase<AlphaType,ValueType,ValueType,ValueType>
  57 {
  58     ValueType operator()( AlphaType alpha,
  59                           ValueType v1,
  60                           ValueType v2 ) const
  61     {
  62         const typename vigra::NumericTraits<AlphaType>::RealPromote fAlpha(
  63             vigra::NumericTraits<AlphaType>::toRealPromote(alpha));
  64         return fAlpha*v1 + (vigra::NumericTraits<AlphaType>::one()-fAlpha)*v2;
  65     }
  66 };
  67
  68 /** Functor template, to calculate alpha blending between two
  69     values. Integer case.
  70
  71     @tpl polarity
  72     When true, 0 means fully transparent, and 1 fully opaque. And vice
  73     versa.
  74  */
  75 template< typename ValueType,
  76           typename AlphaType,
  77           bool     polarity > struct IntegerBlendFunctor;
  78 template< typename ValueType,
  79           typename AlphaType > struct IntegerBlendFunctor<ValueType,AlphaType,true>
  80   : public TernaryFunctorBase<AlphaType,ValueType,ValueType,ValueType>
  81 {
  82     ValueType operator()( AlphaType alpha,
  83                           ValueType v1,
  84                           ValueType v2 ) const
  85     {
  86         return (vigra::NumericTraits<AlphaType>::toPromote(
  87                     vigra::NumericTraits<AlphaType>::max()-alpha)*v1 + alpha*v2) /
  88             vigra::NumericTraits<AlphaType>::max();
  89     }
  90 };
  91 template< typename ValueType,
  92           typename AlphaType > struct IntegerBlendFunctor<ValueType,AlphaType,false>
  93   : public TernaryFunctorBase<AlphaType,ValueType,ValueType,ValueType>
  94 {
  95     ValueType operator()( AlphaType alpha,
  96                           ValueType v1,
  97                           ValueType v2 ) const
  98     {
  99         return (alpha*v1 +
 100                 vigra::NumericTraits<AlphaType>::toPromote(
 101                     vigra::NumericTraits<AlphaType>::max()-alpha)*v2) /
 102             vigra::NumericTraits<AlphaType>::max();
 103     }
 104 };
 105
 106 //-----------------------------------------------------------------------------
 107
 108 template< typename ColorType > struct ColorTraits
 109 {
 110     /// Metafunction to select blend functor from color and alpha type
 111     template< typename AlphaType, bool polarity > struct blend_functor : public
 112         ifScalarIntegral< AlphaType,
 113                           IntegerBlendFunctor< ColorType, AlphaType, polarity >,
 114                           BlendFunctor< ColorType, AlphaType, polarity > > {};
 115
 116     /// @return number of color channels
 117     static int numChannels() { return 1; }
 118
 119     /// Type of a color component (i.e. the type of an individual channel)
 120     typedef ColorType component_type;
 121
 122     /// Calculate normalized distance between color c1 and c2
 123     static inline vigra::NormTraits<ColorType> distance( ColorType c1,
 124                                                          ColorType c2 )
 125     {
 126         return vigra::norm(c1 - c2);
 127     }
 128
 129     static inline component_type toGreyscale( ColorType c )
 130     {
 131         return c;
 132     }
 133
 134     static inline ColorType fromGreyscale( component_type c )
 135     {
 136         return c;
 137     }
 138 };
 139
 140 } // namespace basebmp
 141
 142 #endif /* INCLUDED_BASEBMP_COLORTRAITS_HXX */
 143
 144 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */