Home Explore Help
Register Sign In
devn00b
/
EQ2EMu
9
3
Fork 0
Files Issues 59 Pull Requests 0 Wiki
Tree: 9574459e57
Branches Tags
EQ2EMu
/
EQ2
/
source
/
depends
/
boost_1_72_0
/
libs
/
gil
/
doc
/
html
/
design
/
color_base.html

color_base.html 47 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316 
  1. 

  2. 

  3. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    4. 

  4.   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    5. 

  5. <html xmlns="http://www.w3.org/1999/xhtml">
    6. 

  6.   <head>
    7. 

  7.     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    8. 

  8.     
    9. 

  9.     <title>Color Base - Boost.GIL  documentation</title>
    10. 

  10.     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    11. 

  11.     <link rel="stylesheet" href="../_static/style.css" type="text/css" />
    12. 

  12.     <script type="text/javascript">
    13. 

  13.       var DOCUMENTATION_OPTIONS = {
    14. 

  14.           URL_ROOT:    '../',
    15. 

  15.           VERSION:     '',
    16. 

  16.           COLLAPSE_MODINDEX: false,
    17. 

  17.           FILE_SUFFIX: '.html'
    18. 

  18.       };
    19. 

  19.     </script>
    20. 

  20.     <script type="text/javascript" src="../_static/jquery.js"></script>
    21. 

  21.     <script type="text/javascript" src="../_static/underscore.js"></script>
    22. 

  22.     <script type="text/javascript" src="../_static/doctools.js"></script>
    23. 

  23.     <link rel="index" title="Index" href="../genindex.html" />
    24. 

  24.     <link rel="search" title="Search" href="../search.html" />
    25. 

  25.     <link rel="top" title="Boost.GIL  documentation" href="../index.html" />
    26. 

  26.     <link rel="up" title="Design Guide" href="index.html" />
    27. 

  27.     <link rel="next" title="Pixel" href="pixel.html" />
    28. 

  28.     <link rel="prev" title="Color Space and Layout" href="color_space.html" /> 
    29. 

  29.   </head>
    30. 

  30.   <body>
    31. 

  31.     <div class="header">
    32. 

  32.     <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    33. 

  33.     "header">
    34. 

  34.       <tr>
    35. 

  35.         <td valign="top" width="300">
    36. 

  36.           <h3><a href="../index.html"><img
    37. 

  37.           alt="C++ Boost" src="../_static/gil.png" border="0"></a></h3>
    38. 

  38.         </td>
    39. 

  39. 

  40.         <td >
    41. 

  41.           <h1 align="center"><a href="../index.html"></a></h1>
    42. 

  42.         </td>
    43. 

  43. 	<td>
    44. 

  44.       <div id="searchbox" style="display: none">
    45. 

  45.         <form class="search" action="../search.html" method="get">
    46. 

  46.           <input type="text" name="q" size="18" />
    47. 

  47.           <input type="submit" value="Search" />
    48. 

  48.           <input type="hidden" name="check_keywords" value="yes" />
    49. 

  49.           <input type="hidden" name="area" value="default" />
    50. 

  50.         </form>
    51. 

  51.       </div>
    52. 

  52.       <script type="text/javascript">$('#searchbox').show(0);</script>
    53. 

  53. 	</td>
    54. 

  54.       </tr>
    55. 

  55.     </table>
    56. 

  56.     </div>
    57. 

  57.     <hr/>
    58. 

  58.     <div class="content">
    59. 

  59.     <div class="navbar" style="text-align:right;">
    60. 

  60.       
    61. 

  61.       
    62. 

  62.       <a class="prev" title="Color Space and Layout" href="color_space.html"><img src="../_static/prev.png" alt="prev"/></a>
    63. 

  63.       <a class="up" title="Design Guide" href="index.html"><img src="../_static/up.png" alt="up"/></a>
    64. 

  64.       <a class="next" title="Pixel" href="pixel.html"><img src="../_static/next.png" alt="next"/></a>
    65. 

  65.       
    66. 

  66.     </div>
    67. 

  67.       
    68. 

  68.   <div class="section" id="color-base">
    69. 

  69. <h1>Color Base</h1>
    70. 

  70. <div class="contents local topic" id="contents">
    71. 

  71. <ul class="simple">
    72. 

  72. <li><a class="reference internal" href="#overview" id="id1">Overview</a></li>
    73. 

  73. <li><a class="reference internal" href="#models" id="id2">Models</a></li>
    74. 

  74. <li><a class="reference internal" href="#algorithms" id="id3">Algorithms</a></li>
    75. 

  75. </ul>
    76. 

  76. </div>
    77. 

  77. <div class="section" id="overview">
    78. 

  78. <h2><a class="toc-backref" href="#id1">Overview</a></h2>
    79. 

  79. <p>A color base is a container of color elements. The most common use of color
    80. 

  80. base is in the implementation of a pixel, in which case the color elements are
    81. 

  81. channel values. The color base concept, however, can be used in other
    82. 

  82. scenarios. For example, a planar pixel has channels that are not contiguous in
    83. 

  83. memory. Its reference is a proxy class that uses a color base whose elements
    84. 

  84. are channel references. Its iterator uses a color base whose elements are
    85. 

  85. channel iterators.</p>
    86. 

  86. <p>Color base models must satisfy the following concepts:</p>
    87. 

  87. <div class="highlight-cpp"><div class="highlight"><pre><span class="n">concept</span> <span class="n">ColorBaseConcept</span><span class="o">&lt;</span><span class="k">typename</span> <span class="n">T</span><span class="o">&gt;</span>
    88. 

  88.     <span class="o">:</span> <span class="n">CopyConstructible</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">EqualityComparable</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span>
    89. 

  89. <span class="p">{</span>
    90. 

  90.   <span class="c1">// a GIL layout (the color space and element permutation)</span>
    91. 

  91.   <span class="k">typename</span> <span class="n">layout_t</span><span class="p">;</span>
    92. 

  92. 

  93.   <span class="c1">// The type of K-th element</span>
    94. 

  94.   <span class="k">template</span> <span class="o">&lt;</span><span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">kth_element_type</span><span class="p">;</span>
    95. 

  95.       <span class="n">where</span> <span class="n">Metafunction</span><span class="o">&lt;</span><span class="n">kth_element_type</span><span class="o">&gt;</span><span class="p">;</span>
    96. 

  96. 

  97.   <span class="c1">// The result of at_c</span>
    98. 

  98.   <span class="k">template</span> <span class="o">&lt;</span><span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">kth_element_const_reference_type</span><span class="p">;</span>
    99. 

  99.       <span class="n">where</span> <span class="n">Metafunction</span><span class="o">&lt;</span><span class="n">kth_element_const_reference_type</span><span class="o">&gt;</span><span class="p">;</span>
    100. 

  100. 

  101.   <span class="k">template</span> <span class="o">&lt;</span><span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span> <span class="n">kth_element_const_reference_type</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="n">K</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">at_c</span><span class="p">(</span><span class="n">T</span><span class="p">);</span>
    102. 

  102. 

  103.   <span class="k">template</span> <span class="o">&lt;</span><span class="n">ColorBaseConcept</span> <span class="n">T2</span><span class="o">&gt;</span> <span class="n">where</span> <span class="p">{</span> <span class="n">ColorBasesCompatibleConcept</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="n">T2</span><span class="o">&gt;</span> <span class="p">}</span>
    104. 

  104.       <span class="n">T</span><span class="o">::</span><span class="n">T</span><span class="p">(</span><span class="n">T2</span><span class="p">);</span>
    105. 

  105.   <span class="k">template</span> <span class="o">&lt;</span><span class="n">ColorBaseConcept</span> <span class="n">T2</span><span class="o">&gt;</span> <span class="n">where</span> <span class="p">{</span> <span class="n">ColorBasesCompatibleConcept</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="n">T2</span><span class="o">&gt;</span> <span class="p">}</span>
    106. 

  106.       <span class="kt">bool</span> <span class="k">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">T</span><span class="o">&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span><span class="p">);</span>
    107. 

  107.   <span class="k">template</span> <span class="o">&lt;</span><span class="n">ColorBaseConcept</span> <span class="n">T2</span><span class="o">&gt;</span> <span class="n">where</span> <span class="p">{</span> <span class="n">ColorBasesCompatibleConcept</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="n">T2</span><span class="o">&gt;</span> <span class="p">}</span>
    108. 

  108.       <span class="kt">bool</span> <span class="k">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">T</span><span class="o">&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span><span class="p">);</span>
    109. 

  109. 

  110. <span class="p">};</span>
    111. 

  111. 

  112. <span class="n">concept</span> <span class="n">MutableColorBaseConcept</span><span class="o">&lt;</span><span class="n">ColorBaseConcept</span> <span class="n">T</span><span class="o">&gt;</span>
    113. 

  113.     <span class="o">:</span> <span class="n">Assignable</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">Swappable</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span>
    114. 

  114. <span class="p">{</span>
    115. 

  115.   <span class="k">template</span> <span class="o">&lt;</span><span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">kth_element_reference_type</span><span class="p">;</span>
    116. 

  116.       <span class="n">where</span> <span class="n">Metafunction</span><span class="o">&lt;</span><span class="n">kth_element_reference_type</span><span class="o">&gt;</span><span class="p">;</span>
    117. 

  117. 

  118.   <span class="k">template</span> <span class="o">&lt;</span><span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span> <span class="n">kth_element_reference_type</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="n">K</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">at_c</span><span class="p">(</span><span class="n">T</span><span class="p">);</span>
    119. 

  119. 

  120.   <span class="k">template</span> <span class="o">&lt;</span><span class="n">ColorBaseConcept</span> <span class="n">T2</span><span class="o">&gt;</span> <span class="n">where</span> <span class="p">{</span> <span class="n">ColorBasesCompatibleConcept</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="n">T2</span><span class="o">&gt;</span> <span class="p">}</span>
    121. 

  121.       <span class="n">T</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="n">T</span><span class="o">&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span><span class="p">);</span>
    122. 

  122. <span class="p">};</span>
    123. 

  123. 

  124. <span class="n">concept</span> <span class="n">ColorBaseValueConcept</span><span class="o">&lt;</span><span class="k">typename</span> <span class="n">T</span><span class="o">&gt;</span> <span class="o">:</span> <span class="n">MutableColorBaseConcept</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">Regular</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span>
    125. 

  125. <span class="p">{</span>
    126. 

  126. <span class="p">};</span>
    127. 

  127. 

  128. <span class="n">concept</span> <span class="n">HomogeneousColorBaseConcept</span><span class="o">&lt;</span><span class="n">ColorBaseConcept</span> <span class="n">CB</span><span class="o">&gt;</span>
    129. 

  129. <span class="p">{</span>
    130. 

  130.   <span class="c1">// For all K in [0 ... size&lt;C1&gt;::value-1):</span>
    131. 

  131.   <span class="c1">//     where SameType&lt;kth_element_type&lt;K&gt;::type, kth_element_type&lt;K+1&gt;::type&gt;;</span>
    132. 

  132.   <span class="n">kth_element_const_reference_type</span><span class="o">&lt;</span><span class="mi">0</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">dynamic_at_c</span><span class="p">(</span><span class="k">const</span> <span class="n">CB</span><span class="o">&amp;</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">n</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    133. 

  133. <span class="p">};</span>
    134. 

  134. 

  135. <span class="n">concept</span> <span class="n">MutableHomogeneousColorBaseConcept</span><span class="o">&lt;</span><span class="n">MutableColorBaseConcept</span> <span class="n">CB</span><span class="o">&gt;</span>
    136. 

  136.     <span class="o">:</span> <span class="n">HomogeneousColorBaseConcept</span><span class="o">&lt;</span><span class="n">CB</span><span class="o">&gt;</span>
    137. 

  137. <span class="p">{</span>
    138. 

  138.   <span class="n">kth_element_reference_type</span><span class="o">&lt;</span><span class="mi">0</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">dynamic_at_c</span><span class="p">(</span><span class="k">const</span> <span class="n">CB</span><span class="o">&amp;</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">n</span><span class="p">);</span>
    139. 

  139. <span class="p">};</span>
    140. 

  140. 

  141. <span class="n">concept</span> <span class="n">HomogeneousColorBaseValueConcept</span><span class="o">&lt;</span><span class="k">typename</span> <span class="n">T</span><span class="o">&gt;</span>
    142. 

  142.     <span class="o">:</span> <span class="n">MutableHomogeneousColorBaseConcept</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">,</span> <span class="n">Regular</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span>
    143. 

  143. <span class="p">{</span>
    144. 

  144. <span class="p">};</span>
    145. 

  145. 

  146. <span class="n">concept</span> <span class="n">ColorBasesCompatibleConcept</span><span class="o">&lt;</span><span class="n">ColorBaseConcept</span> <span class="n">C1</span><span class="p">,</span> <span class="n">ColorBaseConcept</span> <span class="n">C2</span><span class="o">&gt;</span>
    147. 

  147. <span class="p">{</span>
    148. 

  148.   <span class="n">where</span> <span class="n">SameType</span><span class="o">&lt;</span><span class="n">C1</span><span class="o">::</span><span class="n">layout_t</span><span class="o">::</span><span class="n">color_space_t</span><span class="p">,</span> <span class="n">C2</span><span class="o">::</span><span class="n">layout_t</span><span class="o">::</span><span class="n">color_space_t</span><span class="o">&gt;</span><span class="p">;</span>
    149. 

  149.   <span class="c1">// also, for all K in [0 ... size&lt;C1&gt;::value):</span>
    150. 

  150.   <span class="c1">//     where Convertible&lt;kth_semantic_element_type&lt;C1,K&gt;::type, kth_semantic_element_type&lt;C2,K&gt;::type&gt;;</span>
    151. 

  151.   <span class="c1">//     where Convertible&lt;kth_semantic_element_type&lt;C2,K&gt;::type, kth_semantic_element_type&lt;C1,K&gt;::type&gt;;</span>
    152. 

  152. <span class="p">};</span>
    153. 

  153. </pre></div>
    154. 

  154. </div>
    155. 

  155. <p>A color base must have an associated layout (which consists of a color space,
    156. 

  156. as well as an ordering of the channels). There are two ways to index the
    157. 

  157. elements of a color base: A physical index corresponds to the way they are
    158. 

  158. ordered in memory, and a semantic index corresponds to the way the elements
    159. 

  159. are ordered in their color space. For example, in the RGB color space the
    160. 

  160. elements are ordered as <code class="docutils literal"><span class="pre">{red_t,</span> <span class="pre">green_t,</span> <span class="pre">blue_t}</span></code>. For a color base with
    161. 

  161. a BGR layout, the first element in physical ordering is the blue element,
    162. 

  162. whereas the first semantic element is the red one.  Models of
    163. 

  163. <code class="docutils literal"><span class="pre">ColorBaseConcept</span></code> are required to provide the <code class="docutils literal"><span class="pre">at_c&lt;K&gt;(ColorBase)</span></code>
    164. 

  164. function, which allows for accessing the elements based on their physical
    165. 

  165. order. GIL provides a <code class="docutils literal"><span class="pre">semantic_at_c&lt;K&gt;(ColorBase)</span></code> function (described
    166. 

  166. later) which can operate on any model of ColorBaseConcept and returns the
    167. 

  167. corresponding semantic element.</p>
    168. 

  168. <p>Two color bases are <em>compatible</em> if they have the same color space and their
    169. 

  169. elements (paired semantically) are convertible to each other.</p>
    170. 

  170. </div>
    171. 

  171. <div class="section" id="models">
    172. 

  172. <h2><a class="toc-backref" href="#id2">Models</a></h2>
    173. 

  173. <p>GIL provides a model for a homogeneous color base (a color base whose elements
    174. 

  174. all have the same type).</p>
    175. 

  175. <div class="highlight-cpp"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">detail</span>
    176. 

  176. <span class="p">{</span>
    177. 

  177.   <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Element</span><span class="p">,</span> <span class="k">typename</span> <span class="n">Layout</span><span class="p">,</span> <span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span>
    178. 

  178.   <span class="k">struct</span> <span class="n">homogeneous_color_base</span><span class="p">;</span>
    179. 

  179. <span class="p">}</span>
    180. 

  180. </pre></div>
    181. 

  181. </div>
    182. 

  182. <p>It is used in the implementation of GIL&#8217;s pixel, planar pixel reference and
    183. 

  183. planar pixel iterator. Another model of <code class="docutils literal"><span class="pre">ColorBaseConcept</span></code> is
    184. 

  184. <code class="docutils literal"><span class="pre">packed_pixel</span></code> - it is a pixel whose channels are bit ranges.</p>
    185. 

  185. <p>See the <a class="reference internal" href="pixel.html"><span class="doc">Pixel</span></a> section for more.</p>
    186. 

  186. </div>
    187. 

  187. <div class="section" id="algorithms">
    188. 

  188. <h2><a class="toc-backref" href="#id3">Algorithms</a></h2>
    189. 

  189. <p>GIL provides the following functions and metafunctions operating on color
    190. 

  190. bases:</p>
    191. 

  191. <div class="highlight-cpp"><div class="highlight"><pre><span class="c1">// Metafunction returning an mpl::int_ equal to the number of elements in the color base</span>
    192. 

  192. <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">ColorBase</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">size</span><span class="p">;</span>
    193. 

  193. 

  194. <span class="c1">// Returns the type of the return value of semantic_at_c&lt;K&gt;(color_base)</span>
    195. 

  195. <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">ColorBase</span><span class="p">,</span> <span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">kth_semantic_element_reference_type</span><span class="p">;</span>
    196. 

  196. <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">ColorBase</span><span class="p">,</span> <span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">kth_semantic_element_const_reference_type</span><span class="p">;</span>
    197. 

  197. 

  198. <span class="c1">// Returns a reference to the element with K-th semantic index.</span>
    199. 

  199. <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">ColorBase</span><span class="p">,</span> <span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span>
    200. 

  200. <span class="k">typename</span> <span class="n">kth_semantic_element_reference_type</span><span class="o">&lt;</span><span class="n">ColorBase</span><span class="p">,</span><span class="n">K</span><span class="o">&gt;::</span><span class="n">type</span>       <span class="n">semantic_at_c</span><span class="p">(</span><span class="n">ColorBase</span><span class="o">&amp;</span> <span class="n">p</span><span class="p">)</span>
    201. 

  201. <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">ColorBase</span><span class="p">,</span> <span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span>
    202. 

  202. <span class="k">typename</span> <span class="n">kth_semantic_element_const_reference_type</span><span class="o">&lt;</span><span class="n">ColorBase</span><span class="p">,</span><span class="n">K</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">semantic_at_c</span><span class="p">(</span><span class="k">const</span> <span class="n">ColorBase</span><span class="o">&amp;</span> <span class="n">p</span><span class="p">)</span>
    203. 

  203. 

  204. <span class="c1">// Returns the type of the return value of get_color&lt;Color&gt;(color_base)</span>
    205. 

  205. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Color</span><span class="p">,</span> <span class="k">typename</span> <span class="n">ColorBase</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">color_reference_t</span><span class="p">;</span>
    206. 

  206. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Color</span><span class="p">,</span> <span class="k">typename</span> <span class="n">ColorBase</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">color_const_reference_t</span><span class="p">;</span>
    207. 

  207. 

  208. <span class="c1">// Returns a reference to the element corresponding to the given color</span>
    209. 

  209. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">ColorBase</span><span class="p">,</span> <span class="k">typename</span> <span class="n">Color</span><span class="o">&gt;</span>
    210. 

  210. <span class="k">typename</span> <span class="n">color_reference_t</span><span class="o">&lt;</span><span class="n">Color</span><span class="p">,</span><span class="n">ColorBase</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">get_color</span><span class="p">(</span><span class="n">ColorBase</span><span class="o">&amp;</span> <span class="n">cb</span><span class="p">,</span> <span class="n">Color</span><span class="o">=</span><span class="n">Color</span><span class="p">());</span>
    211. 

  211. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">ColorBase</span><span class="p">,</span> <span class="k">typename</span> <span class="n">Color</span><span class="o">&gt;</span>
    212. 

  212. <span class="k">typename</span> <span class="n">color_const_reference_t</span><span class="o">&lt;</span><span class="n">Color</span><span class="p">,</span><span class="n">ColorBase</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">get_color</span><span class="p">(</span><span class="k">const</span> <span class="n">ColorBase</span><span class="o">&amp;</span> <span class="n">cb</span><span class="p">,</span> <span class="n">Color</span><span class="o">=</span><span class="n">Color</span><span class="p">());</span>
    213. 

  213. 

  214. <span class="c1">// Returns the element type of the color base. Defined for homogeneous color bases only</span>
    215. 

  215. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">ColorBase</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">element_type</span><span class="p">;</span>
    216. 

  216. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">ColorBase</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">element_reference_type</span><span class="p">;</span>
    217. 

  217. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">ColorBase</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">element_const_reference_type</span><span class="p">;</span>
    218. 

  218. </pre></div>
    219. 

  219. </div>
    220. 

  220. <p>GIL also provides the following algorithms which operate on color bases.
    221. 

  221. Note that they all pair the elements semantically:</p>
    222. 

  222. <div class="highlight-cpp"><div class="highlight"><pre><span class="c1">// Equivalents to std::equal, std::copy, std::fill, std::generate</span>
    223. 

  223. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="o">&gt;</span>   <span class="kt">bool</span> <span class="n">static_equal</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span> <span class="n">p1</span><span class="p">,</span> <span class="k">const</span> <span class="n">CB2</span><span class="o">&amp;</span> <span class="n">p2</span><span class="p">);</span>
    224. 

  224. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Src</span><span class="p">,</span><span class="k">typename</span> <span class="n">Dst</span><span class="o">&gt;</span>   <span class="kt">void</span> <span class="n">static_copy</span><span class="p">(</span><span class="k">const</span> <span class="n">Src</span><span class="o">&amp;</span> <span class="n">src</span><span class="p">,</span> <span class="n">Dst</span><span class="o">&amp;</span> <span class="n">dst</span><span class="p">);</span>
    225. 

  225. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB</span><span class="p">,</span> <span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span>    <span class="kt">void</span> <span class="n">static_generate</span><span class="p">(</span><span class="n">CB</span><span class="o">&amp;</span> <span class="n">dst</span><span class="p">,</span><span class="n">Op</span> <span class="n">op</span><span class="p">);</span>
    226. 

  226. 

  227. <span class="c1">// Equivalents to std::transform</span>
    228. 

  228. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB</span> <span class="p">,</span>             <span class="k">typename</span> <span class="n">Dst</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_transform</span><span class="p">(</span>      <span class="n">CB</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Dst</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    229. 

  229. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB</span> <span class="p">,</span>             <span class="k">typename</span> <span class="n">Dst</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_transform</span><span class="p">(</span><span class="k">const</span> <span class="n">CB</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Dst</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    230. 

  230. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">Dst</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_transform</span><span class="p">(</span>      <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Dst</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    231. 

  231. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">Dst</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_transform</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Dst</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    232. 

  232. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">Dst</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_transform</span><span class="p">(</span>      <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Dst</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    233. 

  233. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">Dst</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_transform</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Dst</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    234. 

  234. 

  235. <span class="c1">// Equivalents to std::for_each</span>
    236. 

  236. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span>                          <span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span>      <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    237. 

  237. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span>                          <span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    238. 

  238. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span>             <span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span>      <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    239. 

  239. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span>             <span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span>      <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    240. 

  240. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span>             <span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    241. 

  241. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span>             <span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    242. 

  242. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB3</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span>      <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB3</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    243. 

  243. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB3</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span>      <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB3</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    244. 

  244. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB3</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span>      <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB3</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    245. 

  245. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB3</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span>      <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB3</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    246. 

  246. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB3</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB3</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    247. 

  247. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB3</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB3</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    248. 

  248. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB3</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span>      <span class="n">CB3</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    249. 

  249. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CB1</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB2</span><span class="p">,</span><span class="k">typename</span> <span class="n">CB3</span><span class="p">,</span><span class="k">typename</span> <span class="n">Op</span><span class="o">&gt;</span> <span class="n">Op</span> <span class="n">static_for_each</span><span class="p">(</span><span class="k">const</span> <span class="n">CB1</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB2</span><span class="o">&amp;</span><span class="p">,</span><span class="k">const</span> <span class="n">CB3</span><span class="o">&amp;</span><span class="p">,</span><span class="n">Op</span><span class="p">);</span>
    250. 

  250. 

  251. <span class="c1">// The following algorithms are only defined for homogeneous color bases:</span>
    252. 

  252. <span class="c1">// Equivalent to std::fill</span>
    253. 

  253. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">HCB</span><span class="p">,</span> <span class="k">typename</span> <span class="n">Element</span><span class="o">&gt;</span> <span class="kt">void</span> <span class="n">static_fill</span><span class="p">(</span><span class="n">HCB</span><span class="o">&amp;</span> <span class="n">p</span><span class="p">,</span> <span class="k">const</span> <span class="n">Element</span><span class="o">&amp;</span> <span class="n">v</span><span class="p">);</span>
    254. 

  254. 

  255. <span class="c1">// Equivalents to std::min_element and std::max_element</span>
    256. 

  256. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">HCB</span><span class="o">&gt;</span> <span class="k">typename</span> <span class="n">element_const_reference_type</span><span class="o">&lt;</span><span class="n">HCB</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">static_min</span><span class="p">(</span><span class="k">const</span> <span class="n">HCB</span><span class="o">&amp;</span><span class="p">);</span>
    257. 

  257. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">HCB</span><span class="o">&gt;</span> <span class="k">typename</span> <span class="n">element_reference_type</span><span class="o">&lt;</span><span class="n">HCB</span><span class="o">&gt;::</span><span class="n">type</span>       <span class="n">static_min</span><span class="p">(</span>      <span class="n">HCB</span><span class="o">&amp;</span><span class="p">);</span>
    258. 

  258. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">HCB</span><span class="o">&gt;</span> <span class="k">typename</span> <span class="n">element_const_reference_type</span><span class="o">&lt;</span><span class="n">HCB</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">static_max</span><span class="p">(</span><span class="k">const</span> <span class="n">HCB</span><span class="o">&amp;</span><span class="p">);</span>
    259. 

  259. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">HCB</span><span class="o">&gt;</span> <span class="k">typename</span> <span class="n">element_reference_type</span><span class="o">&lt;</span><span class="n">HCB</span><span class="o">&gt;::</span><span class="n">type</span>       <span class="n">static_max</span><span class="p">(</span>      <span class="n">HCB</span><span class="o">&amp;</span><span class="p">);</span>
    260. 

  260. </pre></div>
    261. 

  261. </div>
    262. 

  262. <p>These algorithms are designed after the corresponding STL algorithms, except
    263. 

  263. that instead of ranges they take color bases and operate on their elements.
    264. 

  264. In addition, they are implemented with a compile-time recursion (thus the
    265. 

  265. prefix &#8220;static_&#8221;). Finally, they pair the elements semantically instead of
    266. 

  266. based on their physical order in memory.</p>
    267. 

  267. <p>For example, here is the implementation of <code class="docutils literal"><span class="pre">static_equal</span></code>:</p>
    268. 

  268. <div class="highlight-cpp"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">detail</span>
    269. 

  269. <span class="p">{</span>
    270. 

  270.   <span class="k">template</span> <span class="o">&lt;</span><span class="kt">int</span> <span class="n">K</span><span class="o">&gt;</span> <span class="k">struct</span> <span class="n">element_recursion</span>
    271. 

  271.   <span class="p">{</span>
    272. 

  272.     <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">P1</span><span class="p">,</span><span class="k">typename</span> <span class="n">P2</span><span class="o">&gt;</span>
    273. 

  273.     <span class="k">static</span> <span class="kt">bool</span> <span class="n">static_equal</span><span class="p">(</span><span class="k">const</span> <span class="n">P1</span><span class="o">&amp;</span> <span class="n">p1</span><span class="p">,</span> <span class="k">const</span> <span class="n">P2</span><span class="o">&amp;</span> <span class="n">p2</span><span class="p">)</span>
    274. 

  274.     <span class="p">{</span>
    275. 

  275.       <span class="k">return</span> <span class="n">element_recursion</span><span class="o">&lt;</span><span class="n">K</span><span class="o">-</span><span class="mi">1</span><span class="o">&gt;::</span><span class="n">static_equal</span><span class="p">(</span><span class="n">p1</span><span class="p">,</span><span class="n">p2</span><span class="p">)</span> <span class="o">&amp;&amp;</span>
    276. 

  276.              <span class="n">semantic_at_c</span><span class="o">&lt;</span><span class="n">K</span><span class="o">-</span><span class="mi">1</span><span class="o">&gt;</span><span class="p">(</span><span class="n">p1</span><span class="p">)</span><span class="o">==</span><span class="n">semantic_at_c</span><span class="o">&lt;</span><span class="n">N</span><span class="o">-</span><span class="mi">1</span><span class="o">&gt;</span><span class="p">(</span><span class="n">p2</span><span class="p">);</span>
    277. 

  277.     <span class="p">}</span>
    278. 

  278.   <span class="p">};</span>
    279. 

  279.   <span class="k">template</span> <span class="o">&lt;&gt;</span> <span class="k">struct</span> <span class="n">element_recursion</span><span class="o">&lt;</span><span class="mi">0</span><span class="o">&gt;</span>
    280. 

  280.   <span class="p">{</span>
    281. 

  281.     <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">P1</span><span class="p">,</span><span class="k">typename</span> <span class="n">P2</span><span class="o">&gt;</span>
    282. 

  282.     <span class="k">static</span> <span class="kt">bool</span> <span class="n">static_equal</span><span class="p">(</span><span class="k">const</span> <span class="n">P1</span><span class="o">&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">P2</span><span class="o">&amp;</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="nb">true</span><span class="p">;</span> <span class="p">}</span>
    283. 

  283.   <span class="p">};</span>
    284. 

  284. <span class="p">}</span>
    285. 

  285. 

  286. <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">P1</span><span class="p">,</span><span class="k">typename</span> <span class="n">P2</span><span class="o">&gt;</span>
    287. 

  287. <span class="kt">bool</span> <span class="n">static_equal</span><span class="p">(</span><span class="k">const</span> <span class="n">P1</span><span class="o">&amp;</span> <span class="n">p1</span><span class="p">,</span> <span class="k">const</span> <span class="n">P2</span><span class="o">&amp;</span> <span class="n">p2</span><span class="p">)</span>
    288. 

  288. <span class="p">{</span>
    289. 

  289.   <span class="n">gil_function_requires</span><span class="o">&lt;</span><span class="n">ColorSpacesCompatibleConcept</span><span class="o">&lt;</span><span class="n">P1</span><span class="o">::</span><span class="n">layout_t</span><span class="o">::</span><span class="n">color_space_t</span><span class="p">,</span><span class="n">P2</span><span class="o">::</span><span class="n">layout_t</span><span class="o">::</span><span class="n">color_space_t</span><span class="o">&gt;</span> <span class="o">&gt;</span><span class="p">();</span>
    290. 

  290.   <span class="k">return</span> <span class="n">detail</span><span class="o">::</span><span class="n">element_recursion</span><span class="o">&lt;</span><span class="n">size</span><span class="o">&lt;</span><span class="n">P1</span><span class="o">&gt;::</span><span class="n">value</span><span class="o">&gt;::</span><span class="n">static_equal</span><span class="p">(</span><span class="n">p1</span><span class="p">,</span><span class="n">p2</span><span class="p">);</span>
    291. 

  291. <span class="p">}</span>
    292. 

  292. </pre></div>
    293. 

  293. </div>
    294. 

  294. <p>This algorithm is used when invoking <code class="docutils literal"><span class="pre">operator==</span></code> on two pixels, for
    295. 

  295. example. By using semantic accessors we are properly comparing an RGB pixel to
    296. 

  296. a BGR pixel. Notice also that all of the above algorithms taking more than one
    297. 

  297. color base require that they all have the same color space.</p>
    298. 

  298. </div>
    299. 

  299. </div>
    300. 

  300. 

  301. 

  302.     <div class="navbar" style="text-align:right;">
    303. 

  303.       
    304. 

  304.       
    305. 

  305.       <a class="prev" title="Color Space and Layout" href="color_space.html"><img src="../_static/prev.png" alt="prev"/></a>
    306. 

  306.       <a class="up" title="Design Guide" href="index.html"><img src="../_static/up.png" alt="up"/></a>
    307. 

  307.       <a class="next" title="Pixel" href="pixel.html"><img src="../_static/next.png" alt="next"/></a>
    308. 

  308.       
    309. 

  309.     </div>
    310. 

  310.     </div>
    311. 

  311.     <div class="footer" role="contentinfo">
    312. 

  312.       Last updated on 2019-12-10 00:12:10.
    313. 

  313.       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.5.6.
    314. 

  314.     </div>
    315. 

  315.   </body>
    316. 

  316. </html>
    317.