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
/
examples.html

examples.html 30 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270 
  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>Examples - 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="Technicalities" href="technicalities.html" />
    28. 

  28.     <link rel="prev" title="Metafunctions" href="metafunctions.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="Metafunctions" href="metafunctions.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="Technicalities" href="technicalities.html"><img src="../_static/next.png" alt="next"/></a>
    65. 

  65.       
    66. 

  66.     </div>
    67. 

  67.       
    68. 

  68.   <div class="section" id="examples">
    69. 

  69. <h1>Examples</h1>
    70. 

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

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

  72. <li><a class="reference internal" href="#pixel-level-operations" id="id1">Pixel-level Operations</a></li>
    73. 

  73. <li><a class="reference internal" href="#resizing-image-canvas" id="id2">Resizing image canvas</a></li>
    74. 

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

  75. <li><a class="reference internal" href="#using-image-views" id="id4">Using image views</a></li>
    76. 

  76. </ul>
    77. 

  77. </div>
    78. 

  78. <div class="section" id="pixel-level-operations">
    79. 

  79. <h2><a class="toc-backref" href="#id1">Pixel-level Operations</a></h2>
    80. 

  80. <p>Here are some operations you can do with pixel values, pixel pointers and
    81. 

  81. pixel references:</p>
    82. 

  82. <div class="highlight-cpp"><div class="highlight"><pre><span class="n">rgb8_pixel_t</span> <span class="nf">p1</span><span class="p">(</span><span class="mi">255</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">);</span>     <span class="c1">// make a red RGB pixel</span>
    83. 

  83. <span class="n">bgr8_pixel_t</span> <span class="n">p2</span> <span class="o">=</span> <span class="n">p1</span><span class="p">;</span>         <span class="c1">// RGB and BGR are compatible and the channels will be properly mapped.</span>
    84. 

  84. <span class="n">assert</span><span class="p">(</span><span class="n">p1</span><span class="o">==</span><span class="n">p2</span><span class="p">);</span>               <span class="c1">// p2 will also be red.</span>
    85. 

  85. <span class="n">assert</span><span class="p">(</span><span class="n">p2</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">!=</span><span class="n">p1</span><span class="p">[</span><span class="mi">0</span><span class="p">]);</span>         <span class="c1">// operator[] gives physical channel order (as laid down in memory)</span>
    86. 

  86. <span class="n">assert</span><span class="p">(</span><span class="n">semantic_at_c</span><span class="o">&lt;</span><span class="mi">0</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="mi">0</span><span class="o">&gt;</span><span class="p">(</span><span class="n">p2</span><span class="p">));</span> <span class="c1">// this is how to compare the two red channels</span>
    87. 

  87. <span class="n">get_color</span><span class="p">(</span><span class="n">p1</span><span class="p">,</span><span class="n">green_t</span><span class="p">())</span> <span class="o">=</span> <span class="n">get_color</span><span class="p">(</span><span class="n">p2</span><span class="p">,</span><span class="n">blue_t</span><span class="p">());</span>  <span class="c1">// channels can also be accessed by name</span>
    88. 

  88. 

  89. <span class="k">const</span> <span class="kt">unsigned</span> <span class="kt">char</span><span class="o">*</span> <span class="n">r</span><span class="p">;</span>
    90. 

  90. <span class="k">const</span> <span class="kt">unsigned</span> <span class="kt">char</span><span class="o">*</span> <span class="n">g</span><span class="p">;</span>
    91. 

  91. <span class="k">const</span> <span class="kt">unsigned</span> <span class="kt">char</span><span class="o">*</span> <span class="n">b</span><span class="p">;</span>
    92. 

  92. <span class="n">rgb8c_planar_ptr_t</span> <span class="nf">ptr</span><span class="p">(</span><span class="n">r</span><span class="p">,</span><span class="n">g</span><span class="p">,</span><span class="n">b</span><span class="p">);</span> <span class="c1">// constructing const planar pointer from const pointers to each plane</span>
    93. 

  93. 

  94. <span class="n">rgb8c_planar_ref_t</span> <span class="n">ref</span><span class="o">=*</span><span class="n">ptr</span><span class="p">;</span>   <span class="c1">// just like built-in reference, dereferencing a planar pointer returns a planar reference</span>
    95. 

  95. 

  96. <span class="n">p2</span><span class="o">=</span><span class="n">ref</span><span class="p">;</span> <span class="n">p2</span><span class="o">=</span><span class="n">p1</span><span class="p">;</span> <span class="n">p2</span><span class="o">=</span><span class="n">ptr</span><span class="p">[</span><span class="mi">7</span><span class="p">];</span> <span class="n">p2</span><span class="o">=</span><span class="n">rgb8_pixel_t</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">);</span>    <span class="c1">// planar/interleaved references and values to RGB/BGR can be freely mixed</span>
    97. 

  97. 

  98. <span class="c1">//rgb8_planar_ref_t ref2;      // compile error: References have no default constructors</span>
    99. 

  99. <span class="c1">//ref2=*ptr;                   // compile error: Cannot construct non-const reference by dereferencing const pointer</span>
    100. 

  100. <span class="c1">//ptr[3]=p1;                   // compile error: Cannot set the fourth pixel through a const pointer</span>
    101. 

  101. <span class="c1">//p1 = pixel&lt;float, rgb_layout_t&gt;();// compile error: Incompatible channel depth</span>
    102. 

  102. <span class="c1">//p1 = pixel&lt;bits8, rgb_layout_t&gt;();// compile error: Incompatible color space (even though it has the same number of channels)</span>
    103. 

  103. <span class="c1">//p1 = pixel&lt;bits8,rgba_layout_t&gt;();// compile error: Incompatible color space (even though it contains red, green and blue channels)</span>
    104. 

  104. </pre></div>
    105. 

  105. </div>
    106. 

  106. <p>Here is how to use pixels in generic code:</p>
    107. 

  107. <div class="highlight-cpp"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">GrayPixel</span><span class="p">,</span> <span class="k">typename</span> <span class="n">RGBPixel</span><span class="o">&gt;</span>
    108. 

  108. <span class="kt">void</span> <span class="n">gray_to_rgb</span><span class="p">(</span><span class="k">const</span> <span class="n">GrayPixel</span><span class="o">&amp;</span> <span class="n">src</span><span class="p">,</span> <span class="n">RGBPixel</span><span class="o">&amp;</span> <span class="n">dst</span><span class="p">)</span>
    109. 

  109. <span class="p">{</span>
    110. 

  110.   <span class="n">gil_function_requires</span><span class="o">&lt;</span><span class="n">PixelConcept</span><span class="o">&lt;</span><span class="n">GrayPixel</span><span class="o">&gt;</span> <span class="o">&gt;</span><span class="p">();</span>
    111. 

  111.   <span class="n">gil_function_requires</span><span class="o">&lt;</span><span class="n">MutableHomogeneousPixelConcept</span><span class="o">&lt;</span><span class="n">RGBPixel</span><span class="o">&gt;</span> <span class="o">&gt;</span><span class="p">();</span>
    112. 

  112. 

  113.   <span class="k">typedef</span> <span class="k">typename</span> <span class="n">color_space_type</span><span class="o">&lt;</span><span class="n">GrayPixel</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">gray_cs_t</span><span class="p">;</span>
    114. 

  114.   <span class="k">static_assert</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">is_same</span><span class="o">&lt;</span><span class="n">gray_cs_t</span><span class="p">,</span><span class="n">gray_t</span><span class="o">&gt;::</span><span class="n">value</span><span class="p">,</span> <span class="s">&quot;&quot;</span><span class="p">);</span>
    115. 

  115. 

  116.   <span class="k">typedef</span> <span class="k">typename</span> <span class="n">color_space_type</span><span class="o">&lt;</span><span class="n">RGBPixel</span><span class="o">&gt;::</span><span class="n">type</span>  <span class="n">rgb_cs_t</span><span class="p">;</span>
    117. 

  117.   <span class="k">static_assert</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">is_same</span><span class="o">&lt;</span><span class="n">rgb_cs_t</span><span class="p">,</span><span class="n">rgb_t</span><span class="o">&gt;::</span><span class="n">value</span><span class="p">,</span> <span class="s">&quot;&quot;</span><span class="p">);</span>
    118. 

  118. 

  119.   <span class="k">typedef</span> <span class="k">typename</span> <span class="n">channel_type</span><span class="o">&lt;</span><span class="n">GrayPixel</span><span class="o">&gt;::</span><span class="n">type</span> <span class="n">gray_channel_t</span><span class="p">;</span>
    120. 

  120.   <span class="k">typedef</span> <span class="k">typename</span> <span class="n">channel_type</span><span class="o">&lt;</span><span class="n">RGBPixel</span><span class="o">&gt;::</span><span class="n">type</span>  <span class="n">rgb_channel_t</span><span class="p">;</span>
    121. 

  121. 

  122.   <span class="n">gray_channel_t</span> <span class="n">gray</span> <span class="o">=</span> <span class="n">get_color</span><span class="p">(</span><span class="n">src</span><span class="p">,</span><span class="n">gray_color_t</span><span class="p">());</span>
    123. 

  123.   <span class="n">static_fill</span><span class="p">(</span><span class="n">dst</span><span class="p">,</span> <span class="n">channel_convert</span><span class="o">&lt;</span><span class="n">rgb_channel_t</span><span class="o">&gt;</span><span class="p">(</span><span class="n">gray</span><span class="p">));</span>
    124. 

  124. <span class="p">}</span>
    125. 

  125. 

  126. <span class="c1">// example use patterns:</span>
    127. 

  127. 

  128. <span class="c1">// converting gray l-value to RGB and storing at (5,5) in a 16-bit BGR interleaved image:</span>
    129. 

  129. <span class="n">bgr16_view_t</span> <span class="n">b16</span><span class="p">(...);</span>
    130. 

  130. <span class="n">gray_to_rgb</span><span class="p">(</span><span class="n">gray8_pixel_t</span><span class="p">(</span><span class="mi">33</span><span class="p">),</span> <span class="n">b16</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span><span class="mi">5</span><span class="p">));</span>
    131. 

  131. 

  132. <span class="c1">// storing the first pixel of an 8-bit grayscale image as the 5-th pixel of 32-bit planar RGB image:</span>
    133. 

  133. <span class="n">rgb32f_planar_view_t</span> <span class="n">rpv32</span><span class="p">;</span>
    134. 

  134. <span class="n">gray8_view_t</span> <span class="nf">gv8</span><span class="p">(...);</span>
    135. 

  135. <span class="n">gray_to_rgb</span><span class="p">(</span><span class="o">*</span><span class="n">gv8</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">rpv32</span><span class="p">[</span><span class="mi">5</span><span class="p">]);</span>
    136. 

  136. </pre></div>
    137. 

  137. </div>
    138. 

  138. <p>As the example shows, both the source and the destination can be references or
    139. 

  139. values, planar or interleaved, as long as they model <code class="docutils literal"><span class="pre">PixelConcept</span></code> and
    140. 

  140. <code class="docutils literal"><span class="pre">MutablePixelConcept</span></code> respectively.</p>
    141. 

  141. </div>
    142. 

  142. <div class="section" id="resizing-image-canvas">
    143. 

  143. <h2><a class="toc-backref" href="#id2">Resizing image canvas</a></h2>
    144. 

  144. <p>Resizing an image canvas means adding a buffer of pixels around existing
    145. 

  145. pixels. Size of canvas of an image can never be smaller than the image itself.</p>
    146. 

  146. <p>Suppose we want to convolve an image with multiple kernels, the largest of
    147. 

  147. which is 2K+1 x 2K+1 pixels. It may be worth creating a margin of K pixels
    148. 

  148. around the image borders. Here is how to do it:</p>
    149. 

  149. <div class="highlight-cpp"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">SrcView</span><span class="p">,</span>   <span class="c1">// Models ImageViewConcept (the source view)</span>
    150. 

  150.         <span class="k">typename</span> <span class="n">DstImage</span><span class="o">&gt;</span>  <span class="c1">// Models ImageConcept     (the returned image)</span>
    151. 

  151. <span class="kt">void</span> <span class="n">create_with_margin</span><span class="p">(</span><span class="k">const</span> <span class="n">SrcView</span><span class="o">&amp;</span> <span class="n">src</span><span class="p">,</span> <span class="kt">int</span> <span class="n">k</span><span class="p">,</span> <span class="n">DstImage</span><span class="o">&amp;</span> <span class="n">result</span><span class="p">)</span>
    152. 

  152. <span class="p">{</span>
    153. 

  153.   <span class="n">gil_function_requires</span><span class="o">&lt;</span><span class="n">ImageViewConcept</span><span class="o">&lt;</span><span class="n">SrcView</span><span class="o">&gt;</span> <span class="o">&gt;</span><span class="p">();</span>
    154. 

  154.   <span class="n">gil_function_requires</span><span class="o">&lt;</span><span class="n">ImageConcept</span><span class="o">&lt;</span><span class="n">DstImage</span><span class="o">&gt;</span> <span class="o">&gt;</span><span class="p">();</span>
    155. 

  155.   <span class="n">gil_function_requires</span><span class="o">&lt;</span><span class="n">ViewsCompatibleConcept</span><span class="o">&lt;</span><span class="n">SrcView</span><span class="p">,</span> <span class="k">typename</span> <span class="n">DstImage</span><span class="o">::</span><span class="n">view_t</span><span class="o">&gt;</span> <span class="o">&gt;</span><span class="p">();</span>
    156. 

  156. 

  157.   <span class="n">result</span><span class="o">=</span><span class="n">DstImage</span><span class="p">(</span><span class="n">src</span><span class="p">.</span><span class="n">width</span><span class="p">()</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k</span><span class="p">,</span> <span class="n">src</span><span class="p">.</span><span class="n">height</span><span class="p">()</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k</span><span class="p">);</span>
    158. 

  158.   <span class="k">typename</span> <span class="n">DstImage</span><span class="o">::</span><span class="n">view_t</span> <span class="n">centerImg</span><span class="o">=</span><span class="n">subimage_view</span><span class="p">(</span><span class="n">view</span><span class="p">(</span><span class="n">result</span><span class="p">),</span> <span class="n">k</span><span class="p">,</span><span class="n">k</span><span class="p">,</span><span class="n">src</span><span class="p">.</span><span class="n">width</span><span class="p">(),</span><span class="n">src</span><span class="p">.</span><span class="n">height</span><span class="p">());</span>
    159. 

  159.   <span class="n">std</span><span class="o">::</span><span class="n">copy</span><span class="p">(</span><span class="n">src</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">src</span><span class="p">.</span><span class="n">end</span><span class="p">(),</span> <span class="n">centerImg</span><span class="p">.</span><span class="n">begin</span><span class="p">());</span>
    160. 

  160. <span class="p">}</span>
    161. 

  161. </pre></div>
    162. 

  162. </div>
    163. 

  163. <p>We allocated a larger image, then we used <code class="docutils literal"><span class="pre">subimage_view</span></code> to create a
    164. 

  164. shallow image of its center area of top left corner at (k,k) and of identical
    165. 

  165. size as <code class="docutils literal"><span class="pre">src</span></code>, and finally we copied <code class="docutils literal"><span class="pre">src</span></code> into that center image. If the
    166. 

  166. margin needs initialization, we could have done it with <code class="docutils literal"><span class="pre">fill_pixels</span></code>. Here
    167. 

  167. is how to simplify this code using the <code class="docutils literal"><span class="pre">copy_pixels</span></code> algorithm:</p>
    168. 

  168. <div class="highlight-cpp"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">SrcView</span><span class="p">,</span> <span class="k">typename</span> <span class="n">DstImage</span><span class="o">&gt;</span>
    169. 

  169. <span class="kt">void</span> <span class="n">create_with_margin</span><span class="p">(</span><span class="k">const</span> <span class="n">SrcView</span><span class="o">&amp;</span> <span class="n">src</span><span class="p">,</span> <span class="kt">int</span> <span class="n">k</span><span class="p">,</span> <span class="n">DstImage</span><span class="o">&amp;</span> <span class="n">result</span><span class="p">)</span>
    170. 

  170. <span class="p">{</span>
    171. 

  171.   <span class="n">result</span><span class="p">.</span><span class="n">recreate</span><span class="p">(</span><span class="n">src</span><span class="p">.</span><span class="n">width</span><span class="p">()</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k</span><span class="p">,</span> <span class="n">src</span><span class="p">.</span><span class="n">height</span><span class="p">()</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k</span><span class="p">);</span>
    172. 

  172.   <span class="n">copy_pixels</span><span class="p">(</span><span class="n">src</span><span class="p">,</span> <span class="n">subimage_view</span><span class="p">(</span><span class="n">view</span><span class="p">(</span><span class="n">result</span><span class="p">),</span> <span class="n">k</span><span class="p">,</span><span class="n">k</span><span class="p">,</span><span class="n">src</span><span class="p">.</span><span class="n">width</span><span class="p">(),</span><span class="n">src</span><span class="p">.</span><span class="n">height</span><span class="p">()));</span>
    173. 

  173. <span class="p">}</span>
    174. 

  174. </pre></div>
    175. 

  175. </div>
    176. 

  176. <p>(Note also that <code class="docutils literal"><span class="pre">image::recreate</span></code> is more efficient than <code class="docutils literal"><span class="pre">operator=</span></code>, as
    177. 

  177. the latter will do an unnecessary copy construction). Not only does the above
    178. 

  178. example work for planar and interleaved images of any color space and pixel
    179. 

  179. depth; it is also optimized. GIL overrides <code class="docutils literal"><span class="pre">std::copy</span></code> - when called on two
    180. 

  180. identical interleaved images with no padding at the end of rows, it simply
    181. 

  181. does a <code class="docutils literal"><span class="pre">memmove</span></code>. For planar images it does <code class="docutils literal"><span class="pre">memmove</span></code> for each channel.
    182. 

  182. If one of the images has padding, (as in our case) it will try to do
    183. 

  183. <code class="docutils literal"><span class="pre">memmove</span></code> for each row. When an image has no padding, it will use its
    184. 

  184. lightweight horizontal iterator (as opposed to the more complex 1D image
    185. 

  185. iterator that has to check for the end of rows). It choses the fastest method,
    186. 

  186. taking into account both static and run-time parameters.</p>
    187. 

  187. </div>
    188. 

  188. <div class="section" id="histogram">
    189. 

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

  190. <p>The histogram can be computed by counting the number of pixel values that fall
    191. 

  191. in each bin. The following method takes a grayscale (one-dimensional) image
    192. 

  192. view, since only grayscale pixels are convertible to integers:</p>
    193. 

  193. <div class="highlight-cpp"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">GrayView</span><span class="p">,</span> <span class="k">typename</span> <span class="n">R</span><span class="o">&gt;</span>
    194. 

  194. <span class="kt">void</span> <span class="n">grayimage_histogram</span><span class="p">(</span><span class="k">const</span> <span class="n">GrayView</span><span class="o">&amp;</span> <span class="n">img</span><span class="p">,</span> <span class="n">R</span><span class="o">&amp;</span> <span class="n">hist</span><span class="p">)</span>
    195. 

  195. <span class="p">{</span>
    196. 

  196.   <span class="k">for</span> <span class="p">(</span><span class="k">typename</span> <span class="n">GrayView</span><span class="o">::</span><span class="n">iterator</span> <span class="n">it</span><span class="o">=</span><span class="n">img</span><span class="p">.</span><span class="n">begin</span><span class="p">();</span> <span class="n">it</span><span class="o">!=</span><span class="n">img</span><span class="p">.</span><span class="n">end</span><span class="p">();</span> <span class="o">++</span><span class="n">it</span><span class="p">)</span>
    197. 

  197.       <span class="o">++</span><span class="n">hist</span><span class="p">[</span><span class="o">*</span><span class="n">it</span><span class="p">];</span>
    198. 

  198. <span class="p">}</span>
    199. 

  199. </pre></div>
    200. 

  200. </div>
    201. 

  201. <p>Using <code class="docutils literal"><span class="pre">boost::lambda</span></code> and GIL&#8217;s <code class="docutils literal"><span class="pre">for_each_pixel</span></code> algorithm, we can write
    202. 

  202. this more compactly:</p>
    203. 

  203. <div class="highlight-cpp"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">GrayView</span><span class="p">,</span> <span class="k">typename</span> <span class="n">R</span><span class="o">&gt;</span>
    204. 

  204. <span class="kt">void</span> <span class="n">grayimage_histogram</span><span class="p">(</span><span class="k">const</span> <span class="n">GrayView</span><span class="o">&amp;</span> <span class="n">v</span><span class="p">,</span> <span class="n">R</span><span class="o">&amp;</span> <span class="n">hist</span><span class="p">)</span>
    205. 

  205. <span class="p">{</span>
    206. 

  206.   <span class="n">for_each_pixel</span><span class="p">(</span><span class="n">v</span><span class="p">,</span> <span class="o">++</span><span class="n">var</span><span class="p">(</span><span class="n">hist</span><span class="p">)[</span><span class="n">_1</span><span class="p">]);</span>
    207. 

  207. <span class="p">}</span>
    208. 

  208. </pre></div>
    209. 

  209. </div>
    210. 

  210. <p>Where <code class="docutils literal"><span class="pre">for_each_pixel</span></code> invokes <code class="docutils literal"><span class="pre">std::for_each</span></code> and <code class="docutils literal"><span class="pre">var</span></code> and <code class="docutils literal"><span class="pre">_1</span></code> are
    211. 

  211. <code class="docutils literal"><span class="pre">boost::lambda</span></code> constructs. To compute the luminosity histogram, we call the
    212. 

  212. above method using the grayscale view of an image:</p>
    213. 

  213. <div class="highlight-cpp"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">View</span><span class="p">,</span> <span class="k">typename</span> <span class="n">R</span><span class="o">&gt;</span>
    214. 

  214. <span class="kt">void</span> <span class="n">luminosity_histogram</span><span class="p">(</span><span class="k">const</span> <span class="n">View</span><span class="o">&amp;</span> <span class="n">v</span><span class="p">,</span> <span class="n">R</span><span class="o">&amp;</span> <span class="n">hist</span><span class="p">)</span>
    215. 

  215. <span class="p">{</span>
    216. 

  216.   <span class="n">grayimage_histogram</span><span class="p">(</span><span class="n">color_converted_view</span><span class="o">&lt;</span><span class="n">gray8_pixel_t</span><span class="o">&gt;</span><span class="p">(</span><span class="n">v</span><span class="p">),</span><span class="n">hist</span><span class="p">);</span>
    217. 

  217. <span class="p">}</span>
    218. 

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

  219. </div>
    220. 

  220. <p>This is how to invoke it:</p>
    221. 

  221. <div class="highlight-cpp"><div class="highlight"><pre><span class="kt">unsigned</span> <span class="kt">char</span> <span class="n">hist</span><span class="p">[</span><span class="mi">256</span><span class="p">];</span>
    222. 

  222. <span class="n">std</span><span class="o">::</span><span class="n">fill</span><span class="p">(</span><span class="n">hist</span><span class="p">,</span><span class="n">hist</span><span class="o">+</span><span class="mi">256</span><span class="p">,</span><span class="mi">0</span><span class="p">);</span>
    223. 

  223. <span class="n">luminosity_histogram</span><span class="p">(</span><span class="n">my_view</span><span class="p">,</span><span class="n">hist</span><span class="p">);</span>
    224. 

  224. </pre></div>
    225. 

  225. </div>
    226. 

  226. <p>If we want to view the histogram of the second channel of the image in the top
    227. 

  227. left 100x100 area, we call:</p>
    228. 

  228. <div class="highlight-cpp"><div class="highlight"><pre><span class="n">grayimage_histogram</span><span class="p">(</span><span class="n">nth_channel_view</span><span class="p">(</span><span class="n">subimage_view</span><span class="p">(</span><span class="n">img</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">100</span><span class="p">,</span><span class="mi">100</span><span class="p">),</span><span class="mi">1</span><span class="p">),</span><span class="n">hist</span><span class="p">);</span>
    229. 

  229. </pre></div>
    230. 

  230. </div>
    231. 

  231. <p>No pixels are copied and no extra memory is allocated - the code operates
    232. 

  232. directly on the source pixels, which could be in any supported color space and
    233. 

  233. channel depth. They could be either planar or interleaved.</p>
    234. 

  234. </div>
    235. 

  235. <div class="section" id="using-image-views">
    236. 

  236. <h2><a class="toc-backref" href="#id4">Using image views</a></h2>
    237. 

  237. <p>The following code illustrates the power of using image views:</p>
    238. 

  238. <div class="highlight-cpp"><div class="highlight"><pre><span class="n">jpeg_read_image</span><span class="p">(</span><span class="s">&quot;monkey.jpg&quot;</span><span class="p">,</span> <span class="n">img</span><span class="p">);</span>
    239. 

  239. <span class="n">step1</span><span class="o">=</span><span class="n">view</span><span class="p">(</span><span class="n">img</span><span class="p">);</span>
    240. 

  240. <span class="n">step2</span><span class="o">=</span><span class="n">subimage_view</span><span class="p">(</span><span class="n">step1</span><span class="p">,</span> <span class="mi">200</span><span class="p">,</span><span class="mi">300</span><span class="p">,</span> <span class="mi">150</span><span class="p">,</span><span class="mi">150</span><span class="p">);</span>
    241. 

  241. <span class="n">step3</span><span class="o">=</span><span class="n">color_converted_view</span><span class="o">&lt;</span><span class="n">rgb8_view_t</span><span class="p">,</span><span class="n">gray8_pixel_t</span><span class="o">&gt;</span><span class="p">(</span><span class="n">step2</span><span class="p">);</span>
    242. 

  242. <span class="n">step4</span><span class="o">=</span><span class="n">rotated180_view</span><span class="p">(</span><span class="n">step3</span><span class="p">);</span>
    243. 

  243. <span class="n">step5</span><span class="o">=</span><span class="n">subsampled_view</span><span class="p">(</span><span class="n">step4</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">);</span>
    244. 

  244. <span class="n">jpeg_write_view</span><span class="p">(</span><span class="s">&quot;monkey_transform.jpg&quot;</span><span class="p">,</span> <span class="n">step5</span><span class="p">);</span>
    245. 

  245. </pre></div>
    246. 

  246. </div>
    247. 

  247. <p>The intermediate images are shown here:</p>
    248. 

  248. <img alt="../_images/monkey_steps.jpg" src="../_images/monkey_steps.jpg" />
    249. 

  249. <p>Notice that no pixels are ever copied. All the work is done inside
    250. 

  250. <code class="docutils literal"><span class="pre">jpeg_write_view</span></code>. If we call our <code class="docutils literal"><span class="pre">luminosity_histogram</span></code> with
    251. 

  251. <code class="docutils literal"><span class="pre">step5</span></code> it will do the right thing.</p>
    252. 

  252. </div>
    253. 

  253. </div>
    254. 

  254. 

  255. 

  256.     <div class="navbar" style="text-align:right;">
    257. 

  257.       
    258. 

  258.       
    259. 

  259.       <a class="prev" title="Metafunctions" href="metafunctions.html"><img src="../_static/prev.png" alt="prev"/></a>
    260. 

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

  261.       <a class="next" title="Technicalities" href="technicalities.html"><img src="../_static/next.png" alt="next"/></a>
    262. 

  262.       
    263. 

  263.     </div>
    264. 

  264.     </div>
    265. 

  265.     <div class="footer" role="contentinfo">
    266. 

  266.       Last updated on 2019-12-10 00:12:10.
    267. 

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

  268.     </div>
    269. 

  269.   </body>
    270. 

  270. </html>
    271.