Boost GIL


premultiply.hpp
1 //
2 // Copyright 2014 Bill Gallafent
3 //
4 // Distributed under the Boost Software License, Version 1.0
5 // See accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt
7 //
8 #ifndef BOOST_GIL_PREMULTIPLY_HPP
9 #define BOOST_GIL_PREMULTIPLY_HPP
10 
11 #include <boost/gil/rgba.hpp>
12 #include <boost/gil/detail/mp11.hpp>
13 
14 #include <boost/core/ignore_unused.hpp>
15 
16 #include <type_traits>
17 
18 namespace boost { namespace gil {
19 
20 template <typename SrcP, typename DstP>
21 struct channel_premultiply
22 {
23  channel_premultiply(SrcP const & src, DstP & dst)
24  : src_(src), dst_(dst)
25  {}
26 
27  template <typename Channel>
28  void operator()(Channel /* channel */) const
29  {
30  // TODO: Explain why 'channel' input paramater is not used, or used as tag only.
31 
32  // @todo: need to do a "channel_convert" too, in case the channel types aren't the same?
33  get_color(dst_, Channel()) = channel_multiply(get_color(src_,Channel()), alpha_or_max(src_));
34  }
35  SrcP const & src_;
36  DstP & dst_;
37 };
38 
39 namespace detail
40 {
41  template <typename SrcP, typename DstP>
42  void assign_alpha_if(std::true_type, SrcP const &src, DstP &dst)
43  {
44  get_color(dst,alpha_t()) = alpha_or_max(src);
45  }
46 
47  template <typename SrcP, typename DstP>
48  void assign_alpha_if(std::false_type, SrcP const& src, DstP& dst)
49  {
50  // nothing to do
51  boost::ignore_unused(src);
52  boost::ignore_unused(dst);
53  }
54 }
55 
56 struct premultiply
57 {
58  template <typename SrcP, typename DstP>
59  void operator()(const SrcP& src, DstP& dst) const
60  {
61  using src_colour_space_t = typename color_space_type<SrcP>::type;
62  using dst_colour_space_t = typename color_space_type<DstP>::type;
63  using src_colour_channels = mp11::mp_remove<src_colour_space_t, alpha_t>;
64 
65  using has_alpha_t = std::integral_constant<bool, mp11::mp_contains<dst_colour_space_t, alpha_t>::value>;
66  mp11::mp_for_each<src_colour_channels>(channel_premultiply<SrcP, DstP>(src, dst));
67  detail::assign_alpha_if(has_alpha_t(), src, dst);
68  }
69 };
70 
71 template <typename SrcConstRefP, // const reference to the source pixel
72  typename DstP> // Destination pixel value (models PixelValueConcept)
73 class premultiply_deref_fn
74 {
75 public:
76  using const_t = premultiply_deref_fn<SrcConstRefP, DstP>;
77  using value_type = DstP;
78  using reference = value_type; // read-only dereferencing
79  using const_reference = const value_type &;
80  using argument_type = SrcConstRefP;
81  using result_type = reference;
82  static constexpr bool is_mutable = false;
83 
84  result_type operator()(argument_type srcP) const
85  {
86  result_type dstP;
87  premultiply()(srcP,dstP);
88  return dstP;
89  }
90 };
91 
92 template <typename SrcView, typename DstP>
93 struct premultiplied_view_type
94 {
95 private:
96  using src_pix_ref = typename SrcView::const_t::reference; // const reference to pixel in SrcView
97  using deref_t = premultiply_deref_fn<src_pix_ref, DstP>; // the dereference adaptor that performs color conversion
98  using add_ref_t = typename SrcView::template add_deref<deref_t>;
99 public:
100  using type = typename add_ref_t::type; // the color converted view type
101  static type make(const SrcView& sv) { return add_ref_t::make(sv, deref_t()); }
102 };
103 
104 template <typename DstP, typename View> inline
105 typename premultiplied_view_type<View,DstP>::type premultiply_view(const View& src)
106 {
107  return premultiplied_view_type<View,DstP>::make(src);
108 }
109 
110 }} // namespace boost::gil
111 
112 #endif
channel_traits< Channel >::value_type channel_multiply(Channel a, Channel b)
A function multiplying two channels. result = a * b / max_value.
Definition: channel_algorithm.hpp:539
color_element_reference_type< ColorBase, Color >::type get_color(ColorBase &cb, Color=Color())
Mutable accessor to the element associated with a given color name.
Definition: color_base_algorithm.hpp:190