libs/gil/doc/html/design/channel.html

   1
   2
   3 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
   4   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
   5 <html xmlns="http://www.w3.org/1999/xhtml">
   6   <head>
   7     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   8
   9     <title>Channel - Boost.GIL  documentation</title>
  10     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
  11     <link rel="stylesheet" href="../_static/style.css" type="text/css" />
  12     <script type="text/javascript">
  13       var DOCUMENTATION_OPTIONS = {
  14           URL_ROOT:    '../',
  15           VERSION:     '',
  16           COLLAPSE_MODINDEX: false,
  17           FILE_SUFFIX: '.html'
  18       };
  19     </script>
  20     <script type="text/javascript" src="../_static/jquery.js"></script>
  21     <script type="text/javascript" src="../_static/underscore.js"></script>
  22     <script type="text/javascript" src="../_static/doctools.js"></script>
  23     <link rel="index" title="Index" href="../genindex.html" />
  24     <link rel="search" title="Search" href="../search.html" />
  25     <link rel="top" title="Boost.GIL  documentation" href="../index.html" />
  26     <link rel="up" title="Design Guide" href="index.html" />
  27     <link rel="next" title="Color Space and Layout" href="color_space.html" />
  28     <link rel="prev" title="Point" href="point.html" />
  29   </head>
  30   <body>
  31     <div class="header">
  32     <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
  33     "header">
  34       <tr>
  35         <td valign="top" width="300">
  36           <h3><a href="../index.html"><img
  37           alt="C++ Boost" src="../_static/gil.png" border="0"></a></h3>
  38         </td>
  39
  40         <td >
  41           <h1 align="center"><a href="../index.html"></a></h1>
  42         </td>
  43         <td>
  44       <div id="searchbox" style="display: none">
  45         <form class="search" action="../search.html" method="get">
  46           <input type="text" name="q" size="18" />
  47           <input type="submit" value="Search" />
  48           <input type="hidden" name="check_keywords" value="yes" />
  49           <input type="hidden" name="area" value="default" />
  50         </form>
  51       </div>
  52       <script type="text/javascript">$('#searchbox').show(0);</script>
  53         </td>
  54       </tr>
  55     </table>
  56     </div>
  57     <hr/>
  58     <div class="content">
  59     <div class="navbar" style="text-align:right;">
  60
  61
  62       <a class="prev" title="Point" href="point.html"><img src="../_static/prev.png" alt="prev"/></a>
  63       <a class="up" title="Design Guide" href="index.html"><img src="../_static/up.png" alt="up"/></a>
  64       <a class="next" title="Color Space and Layout" href="color_space.html"><img src="../_static/next.png" alt="next"/></a>
  65
  66     </div>
  67
  68   <div class="section" id="channel">
  69 <h1>Channel</h1>
  70 <div class="contents local topic" id="contents">
  71 <ul class="simple">
  72 <li><a class="reference internal" href="#overview" id="id1">Overview</a></li>
  73 <li><a class="reference internal" href="#models" id="id2">Models</a></li>
  74 <li><a class="reference internal" href="#algorithms" id="id3">Algorithms</a></li>
  75 </ul>
  76 </div>
  77 <div class="section" id="overview">
  78 <h2><a class="toc-backref" href="#id1">Overview</a></h2>
  79 <p>A channel indicates the intensity of a color component (for example, the red
  80 channel in an RGB pixel). Typical channel operations are getting, comparing
  81 and setting the channel values. Channels have associated minimum and maximum
  82 value. GIL channels model the following concept:</p>
  83 <div class="highlight-cpp"><div class="highlight"><pre><span class="n">concept</span> <span class="n">ChannelConcept</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">EqualityComparable</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span>
  84 <span class="p">{</span>
  85     <span class="k">typename</span> <span class="n">value_type</span>      <span class="o">=</span> <span class="n">T</span><span class="p">;</span>        <span class="c1">// use channel_traits&lt;T&gt;::value_type to access it</span>
  86     <span class="n">where</span> <span class="n">ChannelValueConcept</span><span class="o">&lt;</span><span class="n">value_type</span><span class="o">&gt;</span><span class="p">;</span>
  87     <span class="k">typename</span> <span class="n">reference</span>       <span class="o">=</span> <span class="n">T</span><span class="o">&amp;</span><span class="p">;</span>       <span class="c1">// use channel_traits&lt;T&gt;::reference to access it</span>
  88     <span class="k">typename</span> <span class="n">pointer</span>         <span class="o">=</span> <span class="n">T</span><span class="o">*</span><span class="p">;</span>       <span class="c1">// use channel_traits&lt;T&gt;::pointer to access it</span>
  89     <span class="k">typename</span> <span class="n">const_reference</span> <span class="o">=</span> <span class="k">const</span> <span class="n">T</span><span class="o">&amp;</span><span class="p">;</span> <span class="c1">// use channel_traits&lt;T&gt;::const_reference to access it</span>
  90     <span class="k">typename</span> <span class="n">const_pointer</span>   <span class="o">=</span> <span class="k">const</span> <span class="n">T</span><span class="o">*</span><span class="p">;</span> <span class="c1">// use channel_traits&lt;T&gt;::const_pointer to access it</span>
  91     <span class="k">static</span> <span class="k">const</span> <span class="kt">bool</span> <span class="n">is_mutable</span><span class="p">;</span>        <span class="c1">// use channel_traits&lt;T&gt;::is_mutable to access it</span>
  92
  93     <span class="k">static</span> <span class="n">T</span> <span class="nf">min_value</span><span class="p">();</span>                <span class="c1">// use channel_traits&lt;T&gt;::min_value to access it</span>
  94     <span class="k">static</span> <span class="n">T</span> <span class="nf">max_value</span><span class="p">();</span>                <span class="c1">// use channel_traits&lt;T&gt;::min_value to access it</span>
  95 <span class="p">};</span>
  96
  97 <span class="n">concept</span> <span class="n">MutableChannelConcept</span><span class="o">&lt;</span><span class="n">ChannelConcept</span> <span class="n">T</span><span class="o">&gt;</span> <span class="o">:</span> <span class="n">Swappable</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">,</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>
  98
  99 <span class="n">concept</span> <span class="n">ChannelValueConcept</span><span class="o">&lt;</span><span class="n">ChannelConcept</span> <span class="n">T</span><span class="o">&gt;</span> <span class="o">:</span> <span class="n">Regular</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span> <span class="p">{};</span>
 100 </pre></div>
 101 </div>
 102 <p>GIL allows built-in integral and floating point types to be channels.
 103 Therefore the associated types and range information are defined in
 104 <code class="docutils literal"><span class="pre">channel_traits</span></code> with the following default implementation:</p>
 105 <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">T</span><span class="o">&gt;</span>
 106 <span class="k">struct</span> <span class="n">channel_traits</span>
 107 <span class="p">{</span>
 108     <span class="k">typedef</span> <span class="n">T</span>         <span class="n">value_type</span><span class="p">;</span>
 109     <span class="k">typedef</span> <span class="n">T</span><span class="o">&amp;</span>        <span class="n">reference</span><span class="p">;</span>
 110     <span class="k">typedef</span> <span class="n">T</span><span class="o">*</span>        <span class="n">pointer</span><span class="p">;</span>
 111     <span class="k">typedef</span> <span class="n">T</span><span class="o">&amp;</span> <span class="k">const</span>  <span class="n">const_reference</span><span class="p">;</span>
 112     <span class="k">typedef</span> <span class="n">T</span><span class="o">*</span> <span class="k">const</span>  <span class="n">const_pointer</span><span class="p">;</span>
 113
 114     <span class="k">static</span> <span class="n">value_type</span> <span class="nf">min_value</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">numeric_limits</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;::</span><span class="n">min</span><span class="p">();</span> <span class="p">}</span>
 115     <span class="k">static</span> <span class="n">value_type</span> <span class="nf">max_value</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">numeric_limits</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;::</span><span class="n">max</span><span class="p">();</span> <span class="p">}</span>
 116 <span class="p">};</span>
 117 </pre></div>
 118 </div>
 119 <p>Two channel types are <em>compatible</em> if they have the same value type:</p>
 120 <div class="highlight-cpp"><div class="highlight"><pre><span class="n">concept</span> <span class="n">ChannelsCompatibleConcept</span><span class="o">&lt;</span><span class="n">ChannelConcept</span> <span class="n">T1</span><span class="p">,</span> <span class="n">ChannelConcept</span> <span class="n">T2</span><span class="o">&gt;</span>
 121 <span class="p">{</span>
 122     <span class="n">where</span> <span class="n">SameType</span><span class="o">&lt;</span><span class="n">T1</span><span class="o">::</span><span class="n">value_type</span><span class="p">,</span> <span class="n">T2</span><span class="o">::</span><span class="n">value_type</span><span class="o">&gt;</span><span class="p">;</span>
 123 <span class="p">};</span>
 124 </pre></div>
 125 </div>
 126 <p>A channel may be <em>convertible</em> to another channel:</p>
 127 <div class="highlight-cpp"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="n">ChannelConcept</span> <span class="n">Src</span><span class="p">,</span> <span class="n">ChannelValueConcept</span> <span class="n">Dst</span><span class="o">&gt;</span>
 128 <span class="n">concept</span> <span class="n">ChannelConvertibleConcept</span>
 129 <span class="p">{</span>
 130     <span class="n">Dst</span> <span class="n">channel_convert</span><span class="p">(</span><span class="n">Src</span><span class="p">);</span>
 131 <span class="p">};</span>
 132 </pre></div>
 133 </div>
 134 <p>Note that <code class="docutils literal"><span class="pre">ChannelConcept</span></code> and <code class="docutils literal"><span class="pre">MutableChannelConcept</span></code> do not require a
 135 default constructor. Channels that also support default construction (and thus
 136 are regular types) model <code class="docutils literal"><span class="pre">ChannelValueConcept</span></code>.
 137 To understand the motivation for this distinction, consider a 16-bit RGB pixel
 138 in a &#8220;565&#8221; bit pattern. Its channels correspond to bit ranges. To support such
 139 channels, we need to create a custom proxy class corresponding to a reference
 140 to a sub-byte channel.
 141 Such a proxy reference class models only <code class="docutils literal"><span class="pre">ChannelConcept</span></code>, because, similar
 142 to native C++ references, it may not have a default constructor.</p>
 143 <p>Note also that algorithms may impose additional requirements on channels,
 144 such as support for arithmetic operations.</p>
 145 <div class="admonition seealso">
 146 <p class="first admonition-title">See also</p>
 147 <ul class="last simple">
 148 <li><a class="reference external" href="reference/structboost_1_1gil_1_1_channel_concept.html">ChannelConcept&lt;T&gt;</a></li>
 149 <li><a class="reference external" href="reference/structboost_1_1gil_1_1_channel_value_concept.html">ChannelValueConcept&lt;T&gt;</a></li>
 150 <li><a class="reference external" href="reference/structboost_1_1gil_1_1_mutable_channel_concept.html">MutableChannelConcept&lt;T&gt;</a></li>
 151 <li><a class="reference external" href="reference/structboost_1_1gil_1_1_channels_compatible_concept.html">ChannelsCompatibleConcept&lt;T1,T2&gt;</a></li>
 152 <li><a class="reference external" href="reference/structboost_1_1gil_1_1_channel_convertible_concept.html">ChannelConvertibleConcept&lt;SrcChannel,DstChannel&gt;</a></li>
 153 </ul>
 154 </div>
 155 </div>
 156 <div class="section" id="models">
 157 <h2><a class="toc-backref" href="#id2">Models</a></h2>
 158 <p>All C++11 fundamental integer and float point types are valid channels.</p>
 159 <p>The minimum and maximum values of a channel modeled by a built-in type
 160 correspond to the minimum and maximum physical range of the built-in type, as
 161 specified by its <code class="docutils literal"><span class="pre">std::numeric_limits</span></code>. Sometimes the physical range is not
 162 appropriate. GIL provides <code class="docutils literal"><span class="pre">scoped_channel_value</span></code>, a model for a channel
 163 adapter that allows for specifying a custom range.
 164 We use it to define a <code class="docutils literal"><span class="pre">[0..1]</span></code> floating point channel type as follows:</p>
 165 <div class="highlight-cpp"><div class="highlight"><pre><span class="k">struct</span> <span class="n">float_zero</span> <span class="p">{</span> <span class="k">static</span> <span class="kt">float</span> <span class="n">apply</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="mf">0.0f</span><span class="p">;</span> <span class="p">}</span> <span class="p">};</span>
 166 <span class="k">struct</span> <span class="n">float_one</span>  <span class="p">{</span> <span class="k">static</span> <span class="kt">float</span> <span class="n">apply</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="mf">1.0f</span><span class="p">;</span> <span class="p">}</span> <span class="p">};</span>
 167 <span class="k">typedef</span> <span class="n">scoped_channel_value</span><span class="o">&lt;</span><span class="kt">float</span><span class="p">,</span><span class="n">float_zero</span><span class="p">,</span><span class="n">float_one</span><span class="o">&gt;</span> <span class="n">bits32f</span><span class="p">;</span>
 168 </pre></div>
 169 </div>
 170 <p>GIL also provides models for channels corresponding to ranges of bits:</p>
 171 <div class="highlight-cpp"><div class="highlight"><pre><span class="c1">// Value of a channel defined over NumBits bits. Models ChannelValueConcept</span>
 172 <span class="k">template</span> <span class="o">&lt;</span><span class="kt">int</span> <span class="n">NumBits</span><span class="o">&gt;</span> <span class="k">class</span> <span class="nc">packed_channel_value</span><span class="p">;</span>
 173
 174 <span class="c1">// Reference to a channel defined over NumBits bits. Models ChannelConcept</span>
 175 <span class="k">template</span> <span class="o">&lt;</span><span class="kt">int</span> <span class="n">FirstBit</span><span class="p">,</span>
 176         <span class="kt">int</span> <span class="n">NumBits</span><span class="p">,</span>       <span class="c1">// Defines the sequence of bits in the data value that contain the channel</span>
 177         <span class="kt">bool</span> <span class="n">Mutable</span><span class="o">&gt;</span>      <span class="c1">// true if the reference is mutable</span>
 178 <span class="k">class</span> <span class="nc">packed_channel_reference</span><span class="p">;</span>
 179
 180 <span class="c1">// Reference to a channel defined over NumBits bits. Its FirstBit is a run-time parameter. Models ChannelConcept</span>
 181 <span class="k">template</span> <span class="o">&lt;</span><span class="kt">int</span> <span class="n">NumBits</span><span class="p">,</span>       <span class="c1">// Defines the sequence of bits in the data value that contain the channel</span>
 182         <span class="kt">bool</span> <span class="n">Mutable</span><span class="o">&gt;</span>      <span class="c1">// true if the reference is mutable</span>
 183 <span class="k">class</span> <span class="nc">packed_dynamic_channel_reference</span><span class="p">;</span>
 184 </pre></div>
 185 </div>
 186 <p>Note that there are two models of a reference proxy which differ based on
 187 whether the offset of the channel range is specified as a template or a
 188 run-time parameter. The first model is faster and more compact while the
 189 second model is more flexible. For example, the second model allows us to
 190 construct an iterator over bit range channels.</p>
 191 </div>
 192 <div class="section" id="algorithms">
 193 <h2><a class="toc-backref" href="#id3">Algorithms</a></h2>
 194 <p>Here is how to construct the three channels of a 16-bit &#8220;565&#8221; pixel and set
 195 them to their maximum value:</p>
 196 <div class="highlight-cpp"><div class="highlight"><pre><span class="k">using</span> <span class="n">channel16_0_5_reference_t</span>  <span class="o">=</span> <span class="n">packed_channel_reference</span><span class="o">&lt;</span><span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="nb">true</span><span class="o">&gt;</span><span class="p">;</span>
 197 <span class="k">using</span> <span class="n">channel16_5_6_reference_t</span>  <span class="o">=</span> <span class="n">packed_channel_reference</span><span class="o">&lt;</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="nb">true</span><span class="o">&gt;</span><span class="p">;</span>
 198 <span class="k">using</span> <span class="n">channel16_11_5_reference_t</span> <span class="o">=</span> <span class="n">packed_channel_reference</span><span class="o">&lt;</span><span class="mi">11</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="nb">true</span><span class="o">&gt;</span><span class="p">;</span>
 199
 200 <span class="n">std</span><span class="o">::</span><span class="kt">uint16_t</span> <span class="n">data</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
 201 <span class="n">channel16_0_5_reference_t</span>  <span class="nf">channel1</span><span class="p">(</span><span class="o">&amp;</span><span class="n">data</span><span class="p">);</span>
 202 <span class="n">channel16_5_6_reference_t</span>  <span class="nf">channel2</span><span class="p">(</span><span class="o">&amp;</span><span class="n">data</span><span class="p">);</span>
 203 <span class="n">channel16_11_5_reference_t</span> <span class="nf">channel3</span><span class="p">(</span><span class="o">&amp;</span><span class="n">data</span><span class="p">);</span>
 204
 205 <span class="n">channel1</span> <span class="o">=</span> <span class="n">channel_traits</span><span class="o">&lt;</span><span class="n">channel16_0_5_reference_t</span><span class="o">&gt;::</span><span class="n">max_value</span><span class="p">();</span>
 206 <span class="n">channel2</span> <span class="o">=</span> <span class="n">channel_traits</span><span class="o">&lt;</span><span class="n">channel16_5_6_reference_t</span><span class="o">&gt;::</span><span class="n">max_value</span><span class="p">();</span>
 207 <span class="n">channel3</span> <span class="o">=</span> <span class="n">channel_traits</span><span class="o">&lt;</span><span class="n">channel16_11_5_reference_t</span><span class="o">&gt;::</span><span class="n">max_value</span><span class="p">();</span>
 208 <span class="n">assert</span><span class="p">(</span><span class="n">data</span> <span class="o">==</span> <span class="mi">65535</span><span class="p">);</span>
 209 </pre></div>
 210 </div>
 211 <p>Assignment, equality comparison and copy construction are defined only between
 212 compatible channels:</p>
 213 <div class="highlight-cpp"><div class="highlight"><pre><span class="n">packed_channel_value</span><span class="o">&lt;</span><span class="mi">5</span><span class="o">&gt;</span> <span class="n">channel_6bit</span> <span class="o">=</span> <span class="n">channel1</span><span class="p">;</span>
 214 <span class="n">channel_6bit</span> <span class="o">=</span> <span class="n">channel3</span><span class="p">;</span>
 215
 216 <span class="c1">// compile error: Assignment between incompatible channels</span>
 217 <span class="c1">//channel_6bit = channel2;</span>
 218 </pre></div>
 219 </div>
 220 <p>All channel models provided by GIL are pairwise convertible:</p>
 221 <div class="highlight-cpp"><div class="highlight"><pre><span class="n">channel1</span> <span class="o">=</span> <span class="n">channel_traits</span><span class="o">&lt;</span><span class="n">channel16_0_5_reference_t</span><span class="o">&gt;::</span><span class="n">max_value</span><span class="p">();</span>
 222 <span class="n">assert</span><span class="p">(</span><span class="n">channel1</span> <span class="o">==</span> <span class="mi">31</span><span class="p">);</span>
 223
 224 <span class="n">bits16</span> <span class="n">chan16</span> <span class="o">=</span> <span class="n">channel_convert</span><span class="o">&lt;</span><span class="n">bits16</span><span class="o">&gt;</span><span class="p">(</span><span class="n">channel1</span><span class="p">);</span>
 225 <span class="n">assert</span><span class="p">(</span><span class="n">chan16</span> <span class="o">==</span> <span class="mi">65535</span><span class="p">);</span>
 226 </pre></div>
 227 </div>
 228 <p>Channel conversion is a lossy operation. GIL&#8217;s channel conversion is a linear
 229 transformation between the ranges of the source and destination channel.
 230 It maps precisely the minimum to the minimum and the maximum to the maximum.
 231 (For example, to convert from uint8_t to uint16_t GIL does not do a bit shift
 232 because it will not properly match the maximum values. Instead GIL multiplies
 233 the source by 257).</p>
 234 <p>All channel models that GIL provides are convertible from/to an integral or
 235 floating point type. Thus they support arithmetic operations. Here are the
 236 channel-level algorithms that GIL provides:</p>
 237 <div class="highlight-cpp"><div class="highlight"><pre><span class="c1">// Converts a source channel value into a destination channel.</span>
 238 <span class="c1">// Linearly maps the value of the source into the range of the destination.</span>
 239 <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">DstChannel</span><span class="p">,</span> <span class="k">typename</span> <span class="n">SrcChannel</span><span class="o">&gt;</span>
 240 <span class="k">typename</span> <span class="n">channel_traits</span><span class="o">&lt;</span><span class="n">DstChannel</span><span class="o">&gt;::</span><span class="n">value_type</span> <span class="n">channel_convert</span><span class="p">(</span><span class="n">SrcChannel</span> <span class="n">src</span><span class="p">);</span>
 241
 242 <span class="c1">// returns max_value - x + min_value</span>
 243 <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Channel</span><span class="o">&gt;</span>
 244 <span class="k">typename</span> <span class="n">channel_traits</span><span class="o">&lt;</span><span class="n">Channel</span><span class="o">&gt;::</span><span class="n">value_type</span> <span class="n">channel_invert</span><span class="p">(</span><span class="n">Channel</span> <span class="n">x</span><span class="p">);</span>
 245
 246 <span class="c1">// returns a * b / max_value</span>
 247 <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Channel</span><span class="o">&gt;</span>
 248 <span class="k">typename</span> <span class="n">channel_traits</span><span class="o">&lt;</span><span class="n">Channel</span><span class="o">&gt;::</span><span class="n">value_type</span> <span class="n">channel_multiply</span><span class="p">(</span><span class="n">Channel</span> <span class="n">a</span><span class="p">,</span> <span class="n">Channel</span> <span class="n">b</span><span class="p">);</span>
 249 </pre></div>
 250 </div>
 251 </div>
 252 </div>
 253
 254
 255     <div class="navbar" style="text-align:right;">
 256
 257
 258       <a class="prev" title="Point" href="point.html"><img src="../_static/prev.png" alt="prev"/></a>
 259       <a class="up" title="Design Guide" href="index.html"><img src="../_static/up.png" alt="up"/></a>
 260       <a class="next" title="Color Space and Layout" href="color_space.html"><img src="../_static/next.png" alt="next"/></a>
 261
 262     </div>
 263     </div>
 264     <div class="footer" role="contentinfo">
 265       Last updated on 2019-12-10 00:12:10.
 266       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.5.6.
 267     </div>
 268   </body>
 269 </html>