<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>Vigranumpy Reference &mdash; vigranumpy v1.7.0 documentation</title>
    <link rel="stylesheet" href="_static/default.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '#',
        VERSION:     '1.7.0',
        COLLAPSE_MODINDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="_static/jquery.js"></script>
    <script type="text/javascript" src="_static/doctools.js"></script>
    <link rel="top" title="vigranumpy v1.7.0 documentation" href="#" /> 
  </head>
  <body>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="modindex.html" title="Global Module Index"
             accesskey="M">modules</a> |</li>
        <li><a href="#">vigranumpy v1.7.0 documentation</a> &raquo;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="vigranumpy-reference">
<h1><a class="toc-backref" href="#id172">Vigranumpy Reference</a><a class="headerlink" href="#vigranumpy-reference" title="Permalink to this headline">¶</a></h1>
<div class="contents topic" id="contents">
<p class="topic-title first">Contents</p>
<ul class="simple">
<li><a class="reference internal" href="#vigranumpy-reference" id="id172">Vigranumpy Reference</a><ul>
<li><a class="reference internal" href="#introduction" id="id173">Introduction</a></li>
<li><a class="reference internal" href="#image-and-volume-data-structures" id="id174">Image and Volume Data Structures</a></li>
<li><a class="reference internal" href="#module-vigra.impex" id="id175">Import and Export Functions</a></li>
<li><a class="reference internal" href="#module-vigra.ufunc" id="id176">Mathematical Functions and Type Coercion</a></li>
<li><a class="reference internal" href="#module-vigra.colors" id="id177">Color and Intensity Manipulation</a></li>
<li><a class="reference internal" href="#module-vigra.filters" id="id178">Filters</a></li>
<li><a class="reference internal" href="#module-vigra.sampling" id="id179">Sampling</a></li>
<li><a class="reference internal" href="#module-vigra.fourier" id="id180">Fourier Transforms</a></li>
<li><a class="reference internal" href="#module-vigra.analysis" id="id181">Image Analysis</a></li>
<li><a class="reference internal" href="#module-vigra.learning" id="id182">Machine Learning</a></li>
<li><a class="reference internal" href="#module-vigra.noise" id="id183">Noise Estimation and Normalization</a></li>
</ul>
</li>
<li><a class="reference internal" href="#indices-and-tables" id="id184">Indices and tables</a></li>
</ul>
</div>
<ul class="simple">
</ul>
<div class="section" id="introduction">
<h2><a class="toc-backref" href="#id173">Introduction</a><a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
<p>Vigranumpy exports the functionality of the C++ image processing library <a class="reference external" href="../vigra/index.html">VIGRA</a> to Python. It can be invoked by importing the vigra module:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">vigra</span>
</pre></div>
</div>
<p>Vigranumpy is based on the popular <a class="reference external" href="http://numpy.scipy.org/">numpy</a> module and uses its ndarray data structure to represent image and volume data. Thus, it is fully interoperable with existing numpy functionality, including various tools for image display such as matplotlib. Since vigranumpy uses <a class="reference external" href="http://www.boost.org/doc/libs">boost_python</a>, it is able to support function overloading (which plain Python does not provide), so that calling syntax is largely uniform, regardless of the type and dimension of the input arguments.</p>
<p>Basic calling syntax is similar to C++, with one important difference: Arguments for output images are optional. If no output image is provided, vigranumpy will allocate it as appropriate. In either case, the output image will be returned by the function, for example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># allocate new result image</span>
<span class="n">smoothImage</span> <span class="o">=</span> <span class="n">vigra</span><span class="o">.</span><span class="n">gaussianSmoothing</span><span class="p">(</span><span class="n">inputImage</span><span class="p">,</span> <span class="n">scale</span><span class="p">)</span>

<span class="c"># reuse and overwrite existing result image</span>
<span class="n">smoothImage</span> <span class="o">=</span> <span class="n">vigra</span><span class="o">.</span><span class="n">gaussianSmoothing</span><span class="p">(</span><span class="n">inputImage</span><span class="p">,</span> <span class="n">scale</span><span class="p">,</span> <span class="n">out</span><span class="o">=</span><span class="n">smoothImage</span><span class="p">)</span>
</pre></div>
</div>
<p>Another important property is vigranumpy&#8217;s indexing convention. In order to be compatible with the index order of the VIGRA C++ version and many other libraries (e.g. <a class="reference external" href="http://qt.nokia.com/">Qt</a> and <a class="reference external" href="http://www.imagemagick.org/">Image Magick</a>), and with standard mathematical notation, images are indexed in the following order:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">value</span> <span class="o">=</span> <span class="n">scalarImage</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">]</span>
<span class="n">value</span> <span class="o">=</span> <span class="n">multibandImage</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">channel</span><span class="p">]</span>

<span class="n">value</span> <span class="o">=</span> <span class="n">scalarVolume</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span><span class="p">]</span>
<span class="n">value</span> <span class="o">=</span> <span class="n">multibandVolume</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span><span class="p">,</span> <span class="n">channel</span><span class="p">]</span>
</pre></div>
</div>
<p>where x is the horizontal axis (increasing left to right), and y is the vertical axis (increasing top to bottom). This convention differs from the <a class="reference external" href="http://www.pythonware.com/products/pil/">Python Imaging Library</a> and Matlab, where the spatial indices must be given in reverse order (e.g. scalarImage[y, x]). Either convention has advantages and disadvantages. In the end, we considered compatibility between the Python and C++ versions of VIGRA to be a very critical feature in order to prevent subtle errors when porting from one language to the other, so we went with the [x, y] order described. Note that this convention does <em>not</em> change the internal representation of the data in memory. It only changes the indexing order, so that one can switch between the different conventions by simply swapping axes, for example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">vigraImage</span>  <span class="o">=</span> <span class="n">array2D</span><span class="o">.</span><span class="n">swapaxes</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="n">vigra</span><span class="o">.</span><span class="n">ScalarImage</span><span class="p">)</span>
<span class="n">array2D</span>     <span class="o">=</span> <span class="n">vigraImage</span><span class="o">.</span><span class="n">swapaxes</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="n">numpy</span><span class="o">.</span><span class="n">ndarray</span><span class="p">)</span>

<span class="n">vigraVolume</span> <span class="o">=</span> <span class="n">array3D</span><span class="o">.</span><span class="n">swapaxes</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="n">vigra</span><span class="o">.</span><span class="n">ScalarVolume</span><span class="p">)</span>
<span class="n">array3D</span>     <span class="o">=</span> <span class="n">vigraVolume</span><span class="o">.</span><span class="n">swapaxes</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="n">numpy</span><span class="o">.</span><span class="n">ndarray</span><span class="p">)</span>
</pre></div>
</div>
<p>In order to turn your own C++ VIGRA functions into Python modules, look at the VIGRA wrapper class
<a class="reference external" href="../../doc/vigra/classvigra_1_1NumpyArray.html">NumpyArray</a> and the source code of the existing vigranumpy modules.</p>
</div>
<div class="section" id="image-and-volume-data-structures">
<h2><a class="toc-backref" href="#id174">Image and Volume Data Structures</a><a class="headerlink" href="#image-and-volume-data-structures" title="Permalink to this headline">¶</a></h2>
<p>Vigranumpy can work directly on numpy.ndarrays. However, plain ndarrays do not carry
any information about the semantics of the different coordinate axes. For example,
one cannot distinguish a 2-dimensional RGB image from a scalar volume data set that
happens to contain only three slices. In order to distinguish between arrays that
have the same structure but different interpretation, vigra.arraytypes provides the
following array classes:</p>
<div class="highlight-python"><pre>numpy.ndarray
    Image
        ScalarImage
        Vector2Image
        Vector3Image
            RGBImage
        Vector4Image
    Volume
        ScalarVolume
        Vector2Volume
        Vector3Volume
            RGBVolume
        Vector4Volume
        Vector6Volume

list
    ImagePyramid</pre>
</div>
<p>where indentation encodes inheritance. Below, we describe <a title="vigra.Image" class="reference internal" href="#vigra.Image"><tt class="xref docutils literal"><span class="pre">Image</span></tt></a>,
<a title="vigra.ScalarImage" class="reference internal" href="#vigra.ScalarImage"><tt class="xref docutils literal"><span class="pre">ScalarImage</span></tt></a>, <a title="vigra.RGBImage" class="reference internal" href="#vigra.RGBImage"><tt class="xref docutils literal"><span class="pre">RGBImage</span></tt></a>, and  <a title="vigra.ImagePyramid" class="reference internal" href="#vigra.ImagePyramid"><tt class="xref docutils literal"><span class="pre">ImagePyramid</span></tt></a>
in detail, the other classes work analogously. The new array classes serve several purposes:</p>
<ul>
<li><p class="first">Semantic interpretation improves code readability.</p>
</li>
<li><p class="first">vigra.arraytypes maximize compatibility with corresponding VIGRA C++ types. In
particular, vigra.arraytype constructors ensure that arrays are created with
the most appropriate memory layout on the Python side. For example, RGBImage
(with dtype=numpy.float32) can be mapped to MultiArrayView&lt;2, RGBValue&lt;float&gt; &gt;.</p>
</li>
<li><p class="first">The distinction of different array types allows for more fine-grained overload
resolution and thus improves mapping from Python to C++. For example,
gaussianSmoothing() works differently for 2D RGBImages and 3D ScalarVolumes,
although both kinds of arrays have the same 3-dimensional memory layout.</p>
</li>
<li><p class="first">The array types help simplify use of the vigranumpy indexing convention:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">image</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">channel</span><span class="p">]</span>
<span class="n">volume</span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span><span class="p">,</span> <span class="n">channel</span><span class="p">]</span>
</pre></div>
</div>
<p>In particular, they overload &#8216;__str__&#8217; and &#8216;__repr__&#8217; (used in print), &#8216;flatten&#8217;,
and &#8216;imshow&#8217; (for matplotlib-based image display) so that these functions work in the
expected way (i.e. images are printed in horizontal scan order and are displayed
upright). Note that other Python imaging modules (such as PIL) use a different
indexing convention (namely image[y, x, channel]).</p>
</li>
<li><p class="first">vigra.arraytypes and vigra.ufunc overload numpy.ufunc (i.e. basic mathematical
functions for arrays). See <a class="reference internal" href="#sec-dtype-coercion"><em>Mathematical Functions and Type Coercion</em></a> for details.</p>
</li>
</ul>
<p>Mapping between C++ types and Python types is controlled by the following two functions:</p>
<dl class="function">
<dt id="vigra.registerPythonArrayType">
<tt class="descclassname">vigra.</tt><tt class="descname">registerPythonArrayType</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.registerPythonArrayType" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>registerPythonArrayType( (str)key, (object)typeobj [, (object)typecheck=None]) -&gt; None :</dt>
<dd><p class="first">registerPythonArrayType(key, typeobj, typecheck = None)</p>
<p>Register a mapping from a C++ type (identified by its string &#8216;key&#8217;) to a
Python-defined array type &#8216;typeobj&#8217;. This mapping is applied whenever an
object of this C++ type is contructed or returned to Python. The registered
&#8216;typeobj&#8217; must be a subclass of numpy.ndarray.</p>
<p>&#8216;key&#8217; can be a fully qualified type (e.g. &#8216;NumpyArray&lt;2, RGBValue&lt;float32&gt; &gt;&#8217;),
or it can contain &#8216;*&#8217; as a placeholder for the value type (e.g.
&#8216;NumpyArray&lt;2, RGBValue&lt;*&gt; &gt;&#8217;). The fully qualified key takes precedence over
the placeholder key when both have been registered. If no key was registered
for a particular C++ type, it is always handled as a plain numpy ndarray. Call
&#8216;listExportedArrayKeys()&#8217; for the list of recognized keys.</p>
<p>Optionally, you can pass a &#8216;typecheck&#8217; function. This function is executed when
an instance of &#8216;typeobj&#8217; is passed to C++ in order to find out whether
conversion into the C++ type identified by &#8216;key&#8217; is allowed. The function must
return &#8216;True&#8217; or &#8216;False&#8217;. This functionality is useful to distinguish object
(e.g. during overload resolution) that have identical memory layout, but
different semantics, such as a multiband image (two spatial dimensions and
one spectral dimension) vs. a singleband volume (three spatial dimensions).</p>
<p>Usage (see vigra/arraytypes.py for a more realistic example):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Image</span><span class="p">(</span><span class="n">numpy</span><span class="o">.</span><span class="n">ndarray</span><span class="p">):</span>
   <span class="n">spatialDimensions</span> <span class="o">=</span> <span class="mi">2</span>
<span class="k">class</span> <span class="nc">Volume</span><span class="p">(</span><span class="n">numpy</span><span class="o">.</span><span class="n">ndarray</span><span class="p">):</span>
   <span class="n">spatialDimensions</span> <span class="o">=</span> <span class="mi">3</span>

<span class="k">def</span> <span class="nf">checkImage</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
   <span class="k">return</span> <span class="n">obj</span><span class="o">.</span><span class="n">spatialDimensions</span> <span class="o">==</span> <span class="mi">2</span>
<span class="k">def</span> <span class="nf">checkVolume</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
   <span class="k">return</span> <span class="n">obj</span><span class="o">.</span><span class="n">spatialDimensions</span> <span class="o">==</span> <span class="mi">3</span>

<span class="n">registerPythonArrayType</span><span class="p">(</span><span class="s">&#39;NumpyArray&lt;2, RGBValue&lt;*&gt; &gt;&#39;</span><span class="p">,</span> <span class="n">Image</span><span class="p">,</span> <span class="n">checkImage</span><span class="p">)</span>
<span class="n">registerPythonArrayType</span><span class="p">(</span><span class="s">&#39;NumpyArray&lt;3, Singleband&lt;*&gt; &gt;&#39;</span><span class="p">,</span> <span class="n">Volume</span><span class="p">,</span> <span class="n">checkVolume</span><span class="p">)</span>
</pre></div>
</div>
<p>The current mapping configuration can be obtained by calling <a title="vigra.listExportedArrayKeys" class="reference internal" href="#vigra.listExportedArrayKeys"><tt class="xref docutils literal"><span class="pre">listExportedArrayKeys()</span></tt></a>.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void registerPythonArrayType(class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt;,struct _object * [,struct _object <a href="#id1"><span class="problematic" id="id2">*</span></a>=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.listExportedArrayKeys">
<tt class="descclassname">vigra.</tt><tt class="descname">listExportedArrayKeys</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.listExportedArrayKeys" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>listExportedArrayKeys() -&gt; list :</dt>
<dd><p class="first">List the currently active type mappings between C++ NumpyArray and Python array types.  This provides status information for <a title="vigra.registerPythonArrayType" class="reference internal" href="#vigra.registerPythonArrayType"><tt class="xref docutils literal"><span class="pre">registerPythonArrayType()</span></tt></a>.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::list listExportedArrayKeys()</dd>
</dl>
</dd>
</dl>
</dd></dl>

<hr class="docutils" />
<dl class="class">
<dt id="vigra.Image">
<em class="property">class </em><tt class="descclassname">vigra.</tt><tt class="descname">Image</tt><a class="headerlink" href="#vigra.Image" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <tt class="xref docutils literal"><span class="pre">vigra.arraytypes._VigraArray</span></tt></p>
<p>Constructor:</p>
<dl class="method">
<dt id="Image.Image">
<tt class="descname">Image</tt><big>(</big><em>obj</em>, <em>dtype=numpy.float32</em>, <em>order='V'</em>, <em>init = True</em>, <em>value = None</em><big>)</big><a class="headerlink" href="#Image.Image" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><em>obj</em> &#8211; a data or shape object (see below)</li>
<li><em>dtype</em> &#8211; desired element type</li>
<li><em>order</em> &#8211; desired memory layout (see below)</li>
<li><em>init</em> (boolean) &#8211; True: initialize the image with zeros; False: do not initialize the image</li>
<li><em>value</em> (convertible to dtype) &#8211; initialize the image with this value (overrides init)</li>
</ul>
</td>
</tr>
</tbody>
</table>
<p><strong>obj</strong> may be one of the following</p>
<ul class="simple">
<li>If obj is a vigra.Image or a subclass, a copy of obj with the
given dtype and order is created, and obj&#8217;s class is transferred.</li>
<li>If obj is another subtype of numpy.ndarray with compatible shape, 
a <em>transposed</em> copy of obj with the given dtype, order and class 
vigra.Image is created. Transposition changes the order of the 
spatial dimensions (and therefore the index order for element access)
from [x,y] or [z,y,x] to the VIGRA convention [x,y] and [x,y,z] 
respectively. The channel dimension is assumed to be the last 
dimension and remains in that position. (Use numpy.rollaxis()
to adjust the input if necessary.)</li>
<li>If obj is a sequence, it is interpreted as a shape. When
the shape is compatible, a new vigra.Image with the given
dtype and order is created.</li>
<li>Otherwise, or if the shape is not compatible, an exception
is raised.</li>
</ul>
<p>A shape is compatible when it has two dimensions (width, height) or three dimensions (width, height, channels).</p>
<p><strong>order</strong> can be &#8216;C&#8217; (C order), &#8216;F&#8217; (Fortran order), &#8216;V&#8217; (vector-valued
order), and &#8216;A&#8217;.</p>
<blockquote>
<dl class="docutils">
<dt>&#8216;C&#8217; and &#8216;F&#8217; order:</dt>
<dd>have the usual numpy meaning</dd>
<dt>&#8216;V&#8217; order:</dt>
<dd>is an interleaved memory layout that simulates vector-
valued pixels or voxels: while the spatial dimensions are arranged
as in Fortran order, the major memory-aligned dimension is the
channel (i.e. last) dimension. Arrays in &#8216;V&#8217;-order are compatible
with vector-valued NumpyArrays. For example, an RGBImage((4,3), uint8)
has strides (3, 12, 1) and is compatible with
NumpyArray&lt;2, RGBValue&lt;UInt8&gt;, UnstridedArrayTag&gt;.</dd>
<dt>&#8216;A&#8217; order:</dt>
<dd>defaults to &#8216;V&#8217; when a new array is created, and means 
&#8216;preserve order&#8217; when an existing array is copied.</dd>
</dl>
</blockquote>
<p>In particular, the following compatibility rules apply (Note that
compatibility with &#8216;UnstridedArrayTag&#8217; implies compatibility with
&#8216;StridedArrayTag&#8217;. Due to their loop order, VIGRA algorithms are
generally more efficient when the memory layout is compatible with
&#8216;UnstridedArrayTag&#8217;. T is the array&#8217;s dtype.):</p>
<blockquote>
<dl class="docutils">
<dt>&#8216;C&#8217;:</dt>
<dd><div class="first last line-block">
<div class="line">NumpyArray&lt;2, T, StridedArrayTag&gt; (if channels=1),</div>
<div class="line">NumpyArray&lt;3, T, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;4, T, StridedArrayTag&gt; (if channels&gt;1),</div>
<div class="line">NumpyArray&lt;2, TinyVector&lt;T, M&gt;, StridedArrayTag&gt; (if channels=M),</div>
<div class="line">NumpyArray&lt;2, RGBValue&lt;T&gt;, StridedArrayTag&gt; (if channels=3),</div>
<div class="line">NumpyArray&lt;2, Singleband&lt;T&gt;, StridedArrayTag&gt; (if channels=1),</div>
<div class="line">NumpyArray&lt;3, Multiband&lt;T&gt;, StridedArrayTag&gt;</div>
</div>
</dd>
<dt>&#8216;F&#8217;:</dt>
<dd><div class="first last line-block">
<div class="line">NumpyArray&lt;2, T, UnstridedArrayTag&gt; (if channels=1),</div>
<div class="line">NumpyArray&lt;3, T, UnstridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;4, T, UnstridedArrayTag&gt; (if channels&gt;1),</div>
<div class="line">NumpyArray&lt;2, Singleband&lt;T&gt;, UnstridedArrayTag&gt; (if channels=1),</div>
<div class="line">NumpyArray&lt;3, Multiband&lt;T&gt;, UnstridedArrayTag&gt;</div>
</div>
</dd>
<dt>&#8216;V&#8217;:</dt>
<dd><div class="first last line-block">
<div class="line">NumpyArray&lt;2, T, UnstridedArrayTag&gt; (if channels=1),</div>
<div class="line">NumpyArray&lt;3, T, UnstridedArrayTag&gt; (if channels=1),</div>
<div class="line">NumpyArray&lt;3, T, StridedArrayTag&gt; (if channels&gt;1),</div>
<div class="line">NumpyArray&lt;4, T, StridedArrayTag&gt; (if channels&gt;1),</div>
<div class="line">NumpyArray&lt;2, Singleband&lt;T&gt;, UnstridedArrayTag&gt; (if channels=1),</div>
<div class="line">NumpyArray&lt;2, TinyVector&lt;T, M&gt;, UnstridedArrayTag&gt; (if channels=M),</div>
<div class="line">NumpyArray&lt;2, RGBValue&lt;T&gt;, UnstridedArrayTag&gt; (if channels=3),</div>
<div class="line">NumpyArray&lt;3, Multiband&lt;T&gt;, UnstridedArrayTag&gt; (if channels=1),</div>
<div class="line">NumpyArray&lt;3, Multiband&lt;T&gt;, StridedArrayTag&gt; (if channels&gt;1)</div>
</div>
</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="attribute">
<dt id="Image.channels">
<tt class="descname">channels</tt><a class="headerlink" href="#Image.channels" title="Permalink to this definition">¶</a></dt>
<dd>the number of channels of this image (e.g. RGB has three channels)</dd></dl>

<dl class="attribute">
<dt id="Image.spatialDimensions">
<tt class="descname">spatialDimensions</tt><a class="headerlink" href="#Image.spatialDimensions" title="Permalink to this definition">¶</a></dt>
<dd>number of spatial dimensions (always 2 for images). This is useful for
distinguishing RGBImage from ScalarVolume in overload resolution.</dd></dl>

<dl class="attribute">
<dt id="vigra.Image.height">
<tt class="descname">height</tt><a class="headerlink" href="#vigra.Image.height" title="Permalink to this definition">¶</a></dt>
<dd>the image&#8217;s height</dd></dl>

<dl class="method">
<dt id="vigra.Image.qimage">
<tt class="descname">qimage</tt><big>(</big><em>normalize=True</em><big>)</big><a class="headerlink" href="#vigra.Image.qimage" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert this image to a Qt QImage (mainly for display purposes).
The present image must have 1 or 3 channels, and the resulting
QImage will have QImage.Format_Indexed8 or QImage.Format_RGB32
respectively.</p>
<blockquote>
<p>The parameter <cite>normalize</cite> can be used to normalize an image&#8217;s
value range to 0..255:</p>
<dl class="docutils">
<dt><cite>normalize</cite> = (nmin, nmax):</dt>
<dd>scale &amp; clip image values from nmin..nmax to 0..255</dd>
<dt><cite>normalize</cite> = nmax:</dt>
<dd>lets nmin default to zero, i.e. scale &amp; clip the range 0..nmax
to 0..255</dd>
<dt><cite>normalize</cite> = True: (default)</dt>
<dd>scale the image&#8217;s actual range min()..max() to 0..255</dd>
<dt><cite>normalize</cite> = False:</dt>
<dd>don&#8217;t scale the image&#8217;s values</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.Image.show">
<tt class="descname">show</tt><big>(</big><em>normalize=True</em><big>)</big><a class="headerlink" href="#vigra.Image.show" title="Permalink to this definition">¶</a></dt>
<dd><p>Display this image in a vigra.pyqt.ImageWindow.</p>
<blockquote>
<p>The parameter <cite>normalize</cite> can be used to normalize an image&#8217;s
value range to 0..255:</p>
<dl class="docutils">
<dt><cite>normalize</cite> = (nmin, nmax):</dt>
<dd>scale &amp; clip image values from nmin..nmax to 0..255</dd>
<dt><cite>normalize</cite> = nmax:</dt>
<dd>lets nmin default to zero, i.e. scale &amp; clip the range 0..nmax
to 0..255</dd>
<dt><cite>normalize</cite> = True: (default)</dt>
<dd>scale the image&#8217;s actual range min()..max() to 0..255</dd>
<dt><cite>normalize</cite> = False:</dt>
<dd>don&#8217;t scale the image&#8217;s values</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="attribute">
<dt id="vigra.Image.width">
<tt class="descname">width</tt><a class="headerlink" href="#vigra.Image.width" title="Permalink to this definition">¶</a></dt>
<dd>the image&#8217;s width</dd></dl>

<dl class="method">
<dt id="vigra.Image.write">
<tt class="descname">write</tt><big>(</big><em>filename</em>, <em>dtype=''</em>, <em>compression=''</em><big>)</big><a class="headerlink" href="#vigra.Image.write" title="Permalink to this definition">¶</a></dt>
<dd>Write an image to a file. Consult <a title="vigra.impex.writeImage" class="reference internal" href="#vigra.impex.writeImage"><tt class="xref docutils literal"><span class="pre">vigra.impex.writeImage()</span></tt></a> for detailed documentation</dd></dl>

<dl class="method">
<dt id="vigra.Image.writeHDF5">
<tt class="descname">writeHDF5</tt><big>(</big><em>filename</em>, <em>pathInFile</em>, <em>dtype=''</em><big>)</big><a class="headerlink" href="#vigra.Image.writeHDF5" title="Permalink to this definition">¶</a></dt>
<dd>Write an image to a HDF5 file. Consult <a title="vigra.impex.writeImageToHDF5" class="reference internal" href="#vigra.impex.writeImageToHDF5"><tt class="xref docutils literal"><span class="pre">vigra.impex.writeImageToHDF5()</span></tt></a> for detailed documentation</dd></dl>

</dd></dl>

<dl class="function">
<dt id="vigra.imshow">
<tt class="descclassname">vigra.</tt><tt class="descname">imshow</tt><big>(</big><em>image</em><big>)</big><a class="headerlink" href="#vigra.imshow" title="Permalink to this definition">¶</a></dt>
<dd>Display a scalar or RGB image by means of matplotlib.
If the image does not have one or three channels, an exception is raised.
The image will be automatically scaled to the range 0...255.</dd></dl>

<hr class="docutils" />
<dl class="class">
<dt id="vigra.ScalarImage">
<em class="property">class </em><tt class="descclassname">vigra.</tt><tt class="descname">ScalarImage</tt><a class="headerlink" href="#vigra.ScalarImage" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <tt class="xref docutils literal"><span class="pre">vigra.arraytypes.Image</span></tt></p>
<p>Constructor:</p>
<dl class="method">
<dt id="ScalarImage.ScalarImage">
<tt class="descname">ScalarImage</tt><big>(</big><em>obj</em>, <em>dtype=numpy.float32</em>, <em>order='V'</em>, <em>init = True</em>, <em>value = None</em><big>)</big><a class="headerlink" href="#ScalarImage.ScalarImage" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><em>obj</em> &#8211; a data or shape object (see below)</li>
<li><em>dtype</em> &#8211; desired element type</li>
<li><em>order</em> &#8211; desired memory layout (see below)</li>
<li><em>init</em> (boolean) &#8211; True: initialize the image with zeros; False: do not initialize the image</li>
<li><em>value</em> (convertible to dtype) &#8211; initialize the image with this value (overrides init)</li>
</ul>
</td>
</tr>
</tbody>
</table>
<p><strong>obj</strong> may be one of the following</p>
<ul class="simple">
<li>If obj is a vigra.ScalarImage or a subclass, a copy of obj with the
given dtype and order is created, and obj&#8217;s class is transferred.</li>
<li>If obj is another subtype of numpy.ndarray with compatible shape, 
a <em>transposed</em> copy of obj with the given dtype, order and class 
vigra.ScalarImage is created. Transposition changes the order of the 
spatial dimensions (and therefore the index order for element access)
from [x,y] or [z,y,x] to the VIGRA convention [x,y] and [x,y,z] 
respectively. The channel dimension is assumed to be the last 
dimension and remains in that position. (Use numpy.rollaxis()
to adjust the input if necessary.)</li>
<li>If obj is a sequence, it is interpreted as a shape. When
the shape is compatible, a new vigra.ScalarImage with the given
dtype and order is created.</li>
<li>Otherwise, or if the shape is not compatible, an exception
is raised.</li>
</ul>
<p>A shape is compatible when it has two dimensions (width, height) or three dimensions (width, height, 1).</p>
<p><strong>order</strong> can be &#8216;C&#8217; (C order), &#8216;F&#8217; (Fortran order), &#8216;V&#8217; (vector-valued
order), and &#8216;A&#8217;.</p>
<blockquote>
<dl class="docutils">
<dt>&#8216;C&#8217; and &#8216;F&#8217; order:</dt>
<dd>have the usual numpy meaning</dd>
<dt>&#8216;V&#8217; order:</dt>
<dd>is an interleaved memory layout that simulates vector-
valued pixels or voxels: while the spatial dimensions are arranged
as in Fortran order, the major memory-aligned dimension is the
channel (i.e. last) dimension. Arrays in &#8216;V&#8217;-order are compatible
with vector-valued NumpyArrays. For example, an RGBImage((4,3), uint8)
has strides (3, 12, 1) and is compatible with
NumpyArray&lt;2, RGBValue&lt;UInt8&gt;, UnstridedArrayTag&gt;.</dd>
<dt>&#8216;A&#8217; order:</dt>
<dd>defaults to &#8216;V&#8217; when a new array is created, and means 
&#8216;preserve order&#8217; when an existing array is copied.</dd>
</dl>
</blockquote>
<p>In particular, the following compatibility rules apply (Note that
compatibility with &#8216;UnstridedArrayTag&#8217; implies compatibility with
&#8216;StridedArrayTag&#8217;. Due to their loop order, VIGRA algorithms are
generally more efficient when the memory layout is compatible with
&#8216;UnstridedArrayTag&#8217;. T is the array&#8217;s dtype.):</p>
<blockquote>
<dl class="docutils">
<dt>&#8216;C&#8217;: </dt>
<dd><div class="first last line-block">
<div class="line">NumpyArray&lt;2, T, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;3, T, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;2, Singleband&lt;T&gt;, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;3, Multiband&lt;T&gt;, StridedArrayTag&gt;</div>
</div>
</dd>
<dt>&#8216;F&#8217;: </dt>
<dd><div class="first last line-block">
<div class="line">NumpyArray&lt;2, T, UnstridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;3, T, UnstridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;2, Singleband&lt;T&gt;, UnstridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;3, Multiband&lt;T&gt;, UnstridedArrayTag&gt;</div>
</div>
</dd>
<dt>&#8216;V&#8217;: </dt>
<dd><div class="first last line-block">
<div class="line">like &#8216;F&#8217;</div>
</div>
</dd>
</dl>
</blockquote>
</dd></dl>

</dd></dl>

<hr class="docutils" />
<dl class="class">
<dt id="vigra.RGBImage">
<em class="property">class </em><tt class="descclassname">vigra.</tt><tt class="descname">RGBImage</tt><a class="headerlink" href="#vigra.RGBImage" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <tt class="xref docutils literal"><span class="pre">vigra.arraytypes.Vector3Image</span></tt></p>
<p>Constructor:</p>
<dl class="method">
<dt id="RGBImage.RGBImage">
<tt class="descname">RGBImage</tt><big>(</big><em>obj</em>, <em>dtype=numpy.float32</em>, <em>order='V'</em>, <em>init = True</em>, <em>value = None</em><big>)</big><a class="headerlink" href="#RGBImage.RGBImage" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><em>obj</em> &#8211; a data or shape object (see below)</li>
<li><em>dtype</em> &#8211; desired element type</li>
<li><em>order</em> &#8211; desired memory layout (see below)</li>
<li><em>init</em> (boolean) &#8211; True: initialize the image with zeros; False: do not initialize the image</li>
<li><em>value</em> (convertible to dtype) &#8211; initialize the image with this value (overrides init)</li>
</ul>
</td>
</tr>
</tbody>
</table>
<p><strong>obj</strong> may be one of the following</p>
<ul class="simple">
<li>If obj is a vigra.RGBImage or a subclass, a copy of obj with the
given dtype and order is created, and obj&#8217;s class is transferred.</li>
<li>If obj is another subtype of numpy.ndarray with compatible shape, 
a <em>transposed</em> copy of obj with the given dtype, order and class 
vigra.RGBImage is created. Transposition changes the order of the 
spatial dimensions (and therefore the index order for element access)
from [x,y] or [z,y,x] to the VIGRA convention [x,y] and [x,y,z] 
respectively. The channel dimension is assumed to be the last 
dimension and remains in that position. (Use numpy.rollaxis()
to adjust the input if necessary.)</li>
<li>If obj is a sequence, it is interpreted as a shape. When
the shape is compatible, a new vigra.RGBImage with the given
dtype and order is created.</li>
<li>Otherwise, or if the shape is not compatible, an exception
is raised.</li>
</ul>
<p>A shape is compatible when it has two dimensions (width, height) or three dimensions (width, height, 3).</p>
<p><strong>order</strong> can be &#8216;C&#8217; (C order), &#8216;F&#8217; (Fortran order), &#8216;V&#8217; (vector-valued
order), and &#8216;A&#8217;.</p>
<blockquote>
<dl class="docutils">
<dt>&#8216;C&#8217; and &#8216;F&#8217; order:</dt>
<dd>have the usual numpy meaning</dd>
<dt>&#8216;V&#8217; order:</dt>
<dd>is an interleaved memory layout that simulates vector-
valued pixels or voxels: while the spatial dimensions are arranged
as in Fortran order, the major memory-aligned dimension is the
channel (i.e. last) dimension. Arrays in &#8216;V&#8217;-order are compatible
with vector-valued NumpyArrays. For example, an RGBImage((4,3), uint8)
has strides (3, 12, 1) and is compatible with
NumpyArray&lt;2, RGBValue&lt;UInt8&gt;, UnstridedArrayTag&gt;.</dd>
<dt>&#8216;A&#8217; order:</dt>
<dd>defaults to &#8216;V&#8217; when a new array is created, and means 
&#8216;preserve order&#8217; when an existing array is copied.</dd>
</dl>
</blockquote>
<p>In particular, the following compatibility rules apply (Note that
compatibility with &#8216;UnstridedArrayTag&#8217; implies compatibility with
&#8216;StridedArrayTag&#8217;. Due to their loop order, VIGRA algorithms are
generally more efficient when the memory layout is compatible with
&#8216;UnstridedArrayTag&#8217;. T is the array&#8217;s dtype.):</p>
<blockquote>
<dl class="docutils">
<dt>&#8216;C&#8217;: </dt>
<dd><div class="first last line-block">
<div class="line">NumpyArray&lt;3, T, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;4, T, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;2, RGBValue&lt;T&gt;, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;2, TinyVector&lt;T, 3&gt;, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;3, Multiband&lt;T&gt;, StridedArrayTag&gt;</div>
</div>
</dd>
<dt>&#8216;F&#8217;: </dt>
<dd><div class="first last line-block">
<div class="line">NumpyArray&lt;3, T, UnstridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;4, T, UnstridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;3, Multiband&lt;T&gt;, UnstridedArrayTag&gt;</div>
</div>
</dd>
<dt>&#8216;V&#8217;: </dt>
<dd><div class="first last line-block">
<div class="line">NumpyArray&lt;3, T, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;4, T, StridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;2, RGBValue&lt;T&gt;, UnstridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;2, TinyVector&lt;T, 3&gt;, UnstridedArrayTag&gt;,</div>
<div class="line">NumpyArray&lt;3, Multiband&lt;T&gt;, StridedArrayTag&gt;</div>
</div>
</dd>
</dl>
</blockquote>
</dd></dl>

</dd></dl>

<hr class="docutils" />
<dl class="class">
<dt id="vigra.ImagePyramid">
<em class="property">class </em><tt class="descclassname">vigra.</tt><tt class="descname">ImagePyramid</tt><big>(</big><em>image</em>, <em>copyImagedestLevel=0</em>, <em>lowestLevel=0</em>, <em>highestLevel=0</em><big>)</big><a class="headerlink" href="#vigra.ImagePyramid" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <tt class="xref docutils literal"><span class="pre">list</span></tt></p>
<p>Create a new pyramid. 
The new pyramid levels range from &#8216;lowestLevel&#8217; to &#8216;highestLevel&#8217; (inclusive),
and the given &#8216;image&#8217; is copied to &#8216;copyImagedestLevel&#8217;. The images at other 
levels are filled with zeros and sized so that the shape is reduced by half 
when going up (to higher levels), and doubled when going down.</p>
<dl class="method">
<dt id="vigra.ImagePyramid.createLevel">
<tt class="descname">createLevel</tt><big>(</big><em>level</em><big>)</big><a class="headerlink" href="#vigra.ImagePyramid.createLevel" title="Permalink to this definition">¶</a></dt>
<dd>Make sure that &#8216;level&#8217; exists. If &#8216;level&#8217; is outside the current range of levels,
empty images of the appropriate shape are inserted into the pyramid.</dd></dl>

<dl class="method">
<dt id="vigra.ImagePyramid.expand">
<tt class="descname">expand</tt><big>(</big><em>srcLevel</em>, <em>destLevel</em>, <em>centerValue=0.41999999999999998</em><big>)</big><a class="headerlink" href="#vigra.ImagePyramid.expand" title="Permalink to this definition">¶</a></dt>
<dd><p>Expand the image at &#8216;srcLevel&#8217; to &#8216;destLevel&#8217;, using the Burt smoothing filter
with the given &#8216;centerValue&#8217;. srcLevel must be larger than destLevel.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__ResamplingConvolutionFilters.html#g7ab3c0a999977eb1d6fee0c9f028fa40">pyramidExpandBurtFilter</a> in the C++ documentation.</p>
</dd></dl>

<dl class="method">
<dt id="vigra.ImagePyramid.expandLaplacian">
<tt class="descname">expandLaplacian</tt><big>(</big><em>srcLevel</em>, <em>destLevel</em>, <em>centerValue=0.41999999999999998</em><big>)</big><a class="headerlink" href="#vigra.ImagePyramid.expandLaplacian" title="Permalink to this definition">¶</a></dt>
<dd><p>Expand the image at &#8216;srcLevel&#8217; to &#8216;destLevel&#8217;, using the Burt smoothing filter
with the given &#8216;centerValue&#8217;, and reconstruct the images for the levels
srcLevel-1 ... destLevel from their Laplacian images. srcLevel must be larger than destLevel.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__ResamplingConvolutionFilters.html#ge6dbd9779529ebf028e7986ff3631d97">pyramidExpandBurtLaplacian</a> in the C++ documentation.</p>
</dd></dl>

<dl class="attribute">
<dt id="vigra.ImagePyramid.highestLevel">
<tt class="descname">highestLevel</tt><a class="headerlink" href="#vigra.ImagePyramid.highestLevel" title="Permalink to this definition">¶</a></dt>
<dd>The pyramids highest level (inclusive).</dd></dl>

<dl class="attribute">
<dt id="vigra.ImagePyramid.lowestLevel">
<tt class="descname">lowestLevel</tt><a class="headerlink" href="#vigra.ImagePyramid.lowestLevel" title="Permalink to this definition">¶</a></dt>
<dd>The pyramids lowest level.</dd></dl>

<dl class="method">
<dt id="vigra.ImagePyramid.reduce">
<tt class="descname">reduce</tt><big>(</big><em>srcLevel</em>, <em>destLevel</em>, <em>centerValue=0.41999999999999998</em><big>)</big><a class="headerlink" href="#vigra.ImagePyramid.reduce" title="Permalink to this definition">¶</a></dt>
<dd><p>Reduce the image at &#8216;srcLevel&#8217; to &#8216;destLevel&#8217;, using the Burt smoothing filter
with the given &#8216;centerValue&#8217;. srcLevel must be smaller than destLevel.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__ResamplingConvolutionFilters.html#ge46c7d78eb8d1fb71c26c00f73e08e02">pyramidReduceBurtFilter</a> in the C++ documentation.</p>
</dd></dl>

<dl class="method">
<dt id="vigra.ImagePyramid.reduceLaplacian">
<tt class="descname">reduceLaplacian</tt><big>(</big><em>srcLevel</em>, <em>destLevel</em>, <em>centerValue=0.41999999999999998</em><big>)</big><a class="headerlink" href="#vigra.ImagePyramid.reduceLaplacian" title="Permalink to this definition">¶</a></dt>
<dd><p>Reduce the image at &#8216;srcLevel&#8217; to &#8216;destLevel&#8217;, using the Burt smoothing filter
with the given &#8216;centerValue&#8217;, and compute Laplacian images for the levels
srcLevel ... destLevel-1. srcLevel must be smaller than destLevel.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__ResamplingConvolutionFilters.html#g4f355d2abb1d486aa755bcfdf3a80b57">pyramidReduceBurtLaplacian</a> in the C++ documentation.</p>
</dd></dl>

</dd></dl>

</div>
<div class="section" id="module-vigra.impex">
<h2><a class="toc-backref" href="#id175">Import and Export Functions</a><a class="headerlink" href="#module-vigra.impex" title="Permalink to this headline">¶</a></h2>
<p>The module vigra.impex defines read and write functions for image and volume data. Note
that the contents of this module are automatically imported into the vigra module, so
you may call &#8216;vigra.readImage(...)&#8217; instead of &#8216;vigra.impex.readImage(...)&#8217; etc.</p>
<dl class="function">
<dt id="vigra.impex.isImage">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">isImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.isImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>isImage( (str)filename) -&gt; bool :</dt>
<dd><p class="first">Check whether the given file name contains image data:</p>
<div class="highlight-python"><pre>isImage(filename) -&gt; bool</pre>
</div>
<p>This function tests whether a file has a supported image format. It checks the first few bytes of the file and compares them with the &#8220;magic strings&#8221; of each recognized image format. If the image format is supported it returns True otherwise False.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>bool isImage(char const <a href="#id3"><span class="problematic" id="id4">*</span></a>)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.listExtensions">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">listExtensions</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.listExtensions" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>listExtensions() -&gt; str :</dt>
<dd><p class="first">Ask for the image file extensions that vigra.impex understands:</p>
<div class="highlight-python"><pre>listExtensions() -&gt; string</pre>
</div>
<p>This function returns a string containing the supported image file extensions for reading and writing with the functions <a title="vigra.impex.readImage" class="reference internal" href="#vigra.impex.readImage"><tt class="xref docutils literal"><span class="pre">readImage()</span></tt></a> and <a title="vigra.impex.writeImage" class="reference internal" href="#vigra.impex.writeImage"><tt class="xref docutils literal"><span class="pre">writeImage()</span></tt></a>.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt; listExtensions()</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.listFormats">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">listFormats</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.listFormats" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>listFormats() -&gt; str :</dt>
<dd><p class="first">Ask for the image file formats that vigra.impex understands:</p>
<div class="highlight-python"><pre>listFormats() -&gt; string</pre>
</div>
<p>This function returns a string containing the supported image file formats for reading and writing with the functions <a title="vigra.impex.readImage" class="reference internal" href="#vigra.impex.readImage"><tt class="xref docutils literal"><span class="pre">readImage()</span></tt></a> and <a title="vigra.impex.writeImage" class="reference internal" href="#vigra.impex.writeImage"><tt class="xref docutils literal"><span class="pre">writeImage()</span></tt></a>.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt; listFormats()</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.readImage">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">readImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.readImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>readImage( (str)filename [, (object)dtype=&#8217;FLOAT&#8217;]) -&gt; object :</dt>
<dd><p class="first">Read an image from a file:</p>
<div class="highlight-python"><pre>readImage(filename, dtype = 'FLOAT') -&gt; Image</pre>
</div>
<p>When import_type is &#8216;UINT8&#8217;, &#8216;INT16&#8217;, &#8216;UINT16&#8217;, &#8216;INT32&#8217;, &#8216;UINT32&#8217;,
&#8216;FLOAT&#8217;, &#8216;DOUBLE&#8217;, or one of the corresponding numpy dtypes (numpy.uint8
etc.), the returned image will have the requested pixel type. If
dtype is &#8216;NATIVE&#8217; or &#8216;&#8217; (empty string), the image is imported with
the original type of the data in the file. Caution: If the requested 
dtype is smaller than the original type in the file, values will be
clipped at the bounds of the representable range, which may not be the
desired behavior.</p>
<p>Supported file formats are listed by the function vigra.impexListFormats().
When filename does not refer to a recognized image file format, an
exception is raised. The file can be checked beforehand with the function
:func:<a href="#id5"><span class="problematic" id="id6">`</span></a>isImage`(filename).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray readImage(char const * [,class boost::python::api::object=&#8217;FLOAT&#8217;])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.readImageFromHDF5">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">readImageFromHDF5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.readImageFromHDF5" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>readImageFromHDF5( (str)filepath, (str)pathInFile [, (object)dtype=&#8217;FLOAT&#8217;]) -&gt; object :</dt>
<dd><p class="first">Read an image from a HDF5 file:</p>
<div class="highlight-python"><pre>readImageFromHDF5(filepath, pathInFile, dtype='FLOAT') -&gt; image</pre>
</div>
<p>If the file contains 3-dimensional data, the innermost (last)
index is interpreted as a channel dimension.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray readImageFromHDF5(char const <a href="#id7"><span class="problematic" id="id8">*</span></a>,char const * [,class boost::python::api::object=&#8217;FLOAT&#8217;])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.readVolume">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">readVolume</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.readVolume" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>readVolume( (str)filename [, (object)dtype=&#8217;FLOAT&#8217;]) -&gt; object :</dt>
<dd><p class="first">Read a 3D volume from a directory:</p>
<div class="highlight-python"><pre>readVolume(filename, dtype = 'FLOAT') -&gt; Volume</pre>
</div>
<p>If the volume is stored in a by-slice manner (e.g. one image per
slice), the &#8216;filename&#8217; can refer to an arbitrary image from the set.
readVolume() then assumes that the slices are enumerated like:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">name_base</span><span class="o">+</span><span class="p">[</span><span class="mi">0</span><span class="o">-</span><span class="mi">9</span><span class="p">]</span><span class="o">+</span><span class="n">name_ext</span>
</pre></div>
</div>
<p>where name_base, the index, and name_ext
are determined automatically. All slice files with the same name base
and extension are considered part of the same volume. Slice numbers
must be non-negative, but can otherwise start anywhere and need not
be successive. Slices will be read in ascending numerical (not
lexicographic) order. All slices must have the same size.</p>
<p>Otherwise, readVolume() will try to read &#8216;filename&#8217; as an info text
file with the following key-value pairs:</p>
<div class="highlight-python"><pre>name = [short descriptive name of the volume] (optional)
filename = [absolute or relative path to raw voxel data file] (required)
gradfile =  [abs. or rel. path to gradient data file] (currently ignored)
description =  [arbitrary description of the data set] (optional)
width = [positive integer] (required)
height = [positive integer] (required)
depth = [positive integer] (required)
datatype = [UNSIGNED_CHAR | UNSIGNED_BYTE] (default: UNSIGNED_CHAR)</pre>
</div>
<p>Lines starting with # are ignored.
When import_type is &#8216;UINT8&#8217;, &#8216;INT16&#8217;, &#8216;UINT16&#8217;, &#8216;INT32&#8217;, &#8216;UINT32&#8217;,
&#8216;FLOAT&#8217;, &#8216;DOUBLE&#8217;, or one of the corresponding numpy dtypes (numpy.uint8
etc.), the returned volume will have the requested pixel type. For details
see the help for <a title="vigra.impex.readImage" class="reference internal" href="#vigra.impex.readImage"><tt class="xref docutils literal"><span class="pre">readImage()</span></tt></a>.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray readVolume(char const * [,class boost::python::api::object=&#8217;FLOAT&#8217;])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.readVolumeFromHDF5">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">readVolumeFromHDF5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.readVolumeFromHDF5" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>readVolumeFromHDF5( (str)filepath, (str)pathInFile [, (object)dtype=&#8217;FLOAT&#8217;]) -&gt; object :</dt>
<dd><p class="first">Read a volume from a file:</p>
<div class="highlight-python"><pre>readVolumeFromHDF5(filepath, pathInFile, dtype='FLOAT') -&gt; volume</pre>
</div>
<p>If the file contains 4-dimensional data, the innermost (last)
index is interpreted as a channel dimension.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray readVolumeFromHDF5(char const <a href="#id9"><span class="problematic" id="id10">*</span></a>,char const * [,class boost::python::api::object=&#8217;FLOAT&#8217;])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.writeImage">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">writeImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.writeImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</dt>
<dd><p class="first">Save an image to a file:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">writeImage</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="n">filename</span><span class="p">,</span> <span class="n">dtype</span> <span class="o">=</span> <span class="s">&#39;&#39;</span><span class="p">,</span> <span class="n">compression</span> <span class="o">=</span> <span class="s">&#39;&#39;</span><span class="p">)</span>
</pre></div>
</div>
<p>Parameters:</p>
<blockquote>
<dl class="docutils">
<dt>image:</dt>
<dd>the image to be saved</dd>
<dt>filename:</dt>
<dd>the file name to save to. The file type will be deduced
from the file name extension (see vigra.impexListExtensions()
for a list of supported extensions).</dd>
<dt>dtype:</dt>
<dd><p class="first">the pixel type written to the file. Possible values:</p>
<blockquote class="last">
<dl class="docutils">
<dt>&#8216;&#8217; or &#8216;NATIVE&#8217;:</dt>
<dd>save with original pixel type, or convert automatically
when this type is unsupported by the target file format</dd>
<dt>&#8216;UINT8&#8217;, &#8216;INT16&#8217;, &#8216;UINT16&#8217;, &#8216;INT32&#8217;, &#8216;UINT32&#8217;, &#8216;FLOAT&#8217;, &#8216;DOUBLE&#8217;:</dt>
<dd>save as specified, or raise exception when this type is not 
supported by the target file format (see list below)</dd>
<dt>&#8216;NBYTE&#8217;:</dt>
<dd>normalize to range 0...255 and then save as &#8216;UINT8&#8217;</dd>
<dt>numpy.uint8, numpy.int16 etc.:</dt>
<dd>behaves like the corresponding string argument</dd>
</dl>
</blockquote>
</dd>
<dt>compression:</dt>
<dd><p class="first">how to compress the data (ignored when compression type is unsupported 
by the file format). Possible values:</p>
<dl class="last docutils">
<dt>&#8216;&#8217; or not given:</dt>
<dd>save with the native compression of the target file format</dd>
<dt>&#8216;RLE&#8217;, &#8216;RunLength&#8217;:</dt>
<dd>use run length encoding (native in BMP, supported by TIFF)</dd>
<dt>&#8216;DEFLATE&#8217;:</dt>
<dd>use deflate encoding (only supported by TIFF)</dd>
<dt>&#8216;LZW&#8217;:</dt>
<dd>use LZW algorithm (only supported by TIFF with LZW enabled)</dd>
<dt>&#8216;ASCII&#8217;:</dt>
<dd>write as ASCII rather than binary file (only supported by PNM)</dd>
<dt>&#8216;1&#8217; ... &#8216;100&#8217;:</dt>
<dd>use this JPEG compression level (only supported by JPEG and TIFF)</dd>
</dl>
</dd>
</dl>
</blockquote>
<p>Supported file formats are listed by the function vigra.impexListFormats().
The different file formats support the following pixel types:</p>
<blockquote>
<dl class="docutils">
<dt>BMP:</dt>
<dd>Microsoft Windows bitmap image file (pixel type: UINT8 as gray and RGB).</dd>
<dt>GIF:</dt>
<dd>CompuServe graphics interchange format; 8-bit color
(pixel type: UINT8 as gray and RGB).</dd>
<dt>JPEG:</dt>
<dd>Joint Photographic Experts Group JFIF format; compressed 24-bit color
(pixel types: UINT8 as gray and RGB). (only available if libjpeg is installed)</dd>
<dt>PNG:</dt>
<dd>Portable Network Graphic (pixel types: UINT8 and UINT16 with
up to 4 channels). (only available if libpng is installed)</dd>
<dt>PBM:</dt>
<dd>Portable bitmap format (black and white).</dd>
<dt>PGM:</dt>
<dd>Portable graymap format (pixel types: UINT8, INT16, INT32 as gray scale)).</dd>
<dt>PNM:</dt>
<dd>Portable anymap (pixel types: UINT8, INT16, INT32, gray and RGB)</dd>
<dt>PPM:</dt>
<dd>Portable pixmap format (pixel types: UINT8, INT16, INT32 as RGB)</dd>
<dt>SUN:</dt>
<dd>SUN Rasterfile (pixel types: UINT8 as gray and RGB).</dd>
<dt>TIFF:</dt>
<dd>Tagged Image File Format (pixel types: UINT8, INT16, INT32, FLOAT, DOUBLE
with up to 4 channels). (only available if libtiff is installed.)</dd>
<dt>VIFF:</dt>
<dd>Khoros Visualization image file (pixel types: UINT8, INT16
INT32, FLOAT, DOUBLE with arbitrary many channels).</dd>
</dl>
</blockquote>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;signed char&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id11"><span class="problematic" id="id12">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</dd>
</dl>
<p>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned __int64&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id13"><span class="problematic" id="id14">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;__int64&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id15"><span class="problematic" id="id16">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned short&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id17"><span class="problematic" id="id18">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;short&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id19"><span class="problematic" id="id20">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned int&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id21"><span class="problematic" id="id22">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;int&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id23"><span class="problematic" id="id24">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;double&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id25"><span class="problematic" id="id26">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id27"><span class="problematic" id="id28">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeImage( (object)image, (str)filename [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id29"><span class="problematic" id="id30">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.writeImageToHDF5">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">writeImageToHDF5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.writeImageToHDF5" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</dt>
<dd><p class="first">Save an image to an HDF5 file:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">writeImageToHDF5</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="n">filepath</span><span class="p">,</span> <span class="n">pathInFile</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="s">&#39;&#39;</span><span class="p">)</span>
</pre></div>
</div>
<p>Argument &#8216;dtype&#8217; is currently ignored.
The resulting HDF5 dataset should be identical to the one created by
the Python module <a class="reference external" href="http://h5py.alfven.org/">h5py</a> as follows:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">vigra</span><span class="o">,</span> <span class="nn">h5py</span>
<span class="n">image</span> <span class="o">=</span> <span class="n">vigra</span><span class="o">.</span><span class="n">readImage</span><span class="p">(</span><span class="n">filename</span><span class="p">)</span>
<span class="n">vigra</span><span class="o">.</span><span class="n">writeImageToHDF5</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="s">&#39;vigra_export.h5&#39;</span><span class="p">,</span> <span class="s">&#39;MyImage&#39;</span><span class="p">)</span>
<span class="n">h5py_file</span> <span class="o">=</span> <span class="n">h5py</span><span class="o">.</span><span class="n">File</span><span class="p">(</span><span class="s">&#39;h5py_export.h5&#39;</span><span class="p">,</span> <span class="s">&#39;w&#39;</span><span class="p">)</span>
<span class="n">h5py_file</span><span class="o">.</span><span class="n">create_dataset</span><span class="p">(</span><span class="s">&#39;MyImage&#39;</span><span class="p">,</span> <span class="n">data</span><span class="o">=</span><span class="n">image</span><span class="o">.</span><span class="n">swapaxes</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">))</span>
<span class="n">h5py_file</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>
</div>
<p>(note the axes transposition which accounts for the VIGRA indexing convention).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;signed char&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id31"><span class="problematic" id="id32">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</dd>
</dl>
<p>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned __int64&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id33"><span class="problematic" id="id34">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;__int64&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id35"><span class="problematic" id="id36">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned short&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id37"><span class="problematic" id="id38">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;short&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id39"><span class="problematic" id="id40">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned int&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id41"><span class="problematic" id="id42">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;int&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id43"><span class="problematic" id="id44">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;double&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id45"><span class="problematic" id="id46">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id47"><span class="problematic" id="id48">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeImageToHDF5( (object)image, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeImageToHDF5(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id49"><span class="problematic" id="id50">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.writeVolume">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">writeVolume</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.writeVolume" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</dt>
<dd><p class="first">Wrtie a volume as a sequence of images:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">writeVolume</span><span class="p">(</span><span class="n">volume</span><span class="p">,</span> <span class="n">filename_base</span><span class="p">,</span> <span class="n">filename_ext</span><span class="p">,</span> <span class="n">dtype</span> <span class="o">=</span> <span class="s">&#39;&#39;</span><span class="p">,</span> <span class="n">compression</span> <span class="o">=</span> <span class="s">&#39;&#39;</span><span class="p">)</span>
</pre></div>
</div>
<p>The resulting image sequence will be enumerated in the form:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">filename_base</span><span class="o">+</span><span class="p">[</span><span class="mi">0</span><span class="o">-</span><span class="mi">9</span><span class="p">]</span><span class="o">+</span><span class="n">filename_ext</span>
</pre></div>
</div>
<p>Parameters &#8216;dtype&#8217; and &#8216;compression&#8217; will be handled as in <a title="vigra.impex.writeImage" class="reference internal" href="#vigra.impex.writeImage"><tt class="xref docutils literal"><span class="pre">writeImage()</span></tt></a>.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;signed char&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id51"><span class="problematic" id="id52">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id53"><span class="problematic" id="id54">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</dd>
</dl>
<p>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned __int64&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id55"><span class="problematic" id="id56">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id57"><span class="problematic" id="id58">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;__int64&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id59"><span class="problematic" id="id60">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id61"><span class="problematic" id="id62">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned short&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id63"><span class="problematic" id="id64">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id65"><span class="problematic" id="id66">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;short&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id67"><span class="problematic" id="id68">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id69"><span class="problematic" id="id70">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned int&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id71"><span class="problematic" id="id72">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id73"><span class="problematic" id="id74">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;int&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id75"><span class="problematic" id="id76">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id77"><span class="problematic" id="id78">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;double&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id79"><span class="problematic" id="id80">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id81"><span class="problematic" id="id82">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id83"><span class="problematic" id="id84">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id85"><span class="problematic" id="id86">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
<p>writeVolume( (object)volume, (str)filename_base, (str)filename_ext [, (object)dtype=&#8217;&#8217; [, (str)compression=&#8217;&#8216;]]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolume(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id87"><span class="problematic" id="id88">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8217; [,char const <a href="#id89"><span class="problematic" id="id90">*</span></a>=&#8217;&#8216;]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.impex.writeVolumeToHDF5">
<tt class="descclassname">vigra.impex.</tt><tt class="descname">writeVolumeToHDF5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.impex.writeVolumeToHDF5" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</dt>
<dd><p class="first">Save a volume to an HDF5 file:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">writeVolumeToHDF5</span><span class="p">(</span><span class="n">volume</span><span class="p">,</span> <span class="n">filepath</span><span class="p">,</span> <span class="n">pathInFile</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="s">&#39;&#39;</span><span class="p">)</span>
</pre></div>
</div>
<p>Argument &#8216;dtype&#8217; is currently ignored.
The resulting HDF5 dataset should be identical to the one created by
the Python module <a class="reference external" href="http://h5py.alfven.org/">h5py</a> as follows:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">vigra</span><span class="o">,</span> <span class="nn">h5py</span>
<span class="n">volume</span> <span class="o">=</span> <span class="n">vigra</span><span class="o">.</span><span class="n">readVolume</span><span class="p">(</span><span class="n">filename</span><span class="p">)</span>
<span class="n">vigra</span><span class="o">.</span><span class="n">writeVolumeToHDF5</span><span class="p">(</span><span class="n">volume</span><span class="p">,</span> <span class="s">&#39;vigra_export.h5&#39;</span><span class="p">,</span> <span class="s">&#39;MyVolume&#39;</span><span class="p">)</span>
<span class="n">h5py_file</span> <span class="o">=</span> <span class="n">h5py</span><span class="o">.</span><span class="n">File</span><span class="p">(</span><span class="s">&#39;h5py_export.h5&#39;</span><span class="p">,</span> <span class="s">&#39;w&#39;</span><span class="p">)</span>
<span class="n">h5py_file</span><span class="o">.</span><span class="n">create_dataset</span><span class="p">(</span><span class="s">&#39;MyVolume&#39;</span><span class="p">,</span> <span class="n">data</span><span class="o">=</span><span class="n">volume</span><span class="o">.</span><span class="n">swapaxes</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span>
<span class="n">h5py_file</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>
</div>
<p>(note the axes transposition which accounts for the VIGRA indexing convention).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;signed char&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id92"><span class="problematic" id="id93">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</dd>
</dl>
<p>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned __int64&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id94"><span class="problematic" id="id95">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;__int64&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id96"><span class="problematic" id="id97">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned short&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id98"><span class="problematic" id="id99">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;short&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id100"><span class="problematic" id="id101">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned int&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id102"><span class="problematic" id="id103">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;int&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id104"><span class="problematic" id="id105">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;double&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id106"><span class="problematic" id="id107">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id108"><span class="problematic" id="id109">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
<p>writeVolumeToHDF5( (object)volume, (str)filepath, (str)pathInFile [, (object)dtype=&#8217;&#8216;]) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void writeVolumeToHDF5(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,char const <a href="#id110"><span class="problematic" id="id111">*</span></a>,char const * [,class boost::python::api::object=&#8217;&#8216;])</dd>
</dl>
</blockquote>
</dd></dl>

</div>
<div class="section" id="module-vigra.ufunc">
<span id="sec-dtype-coercion"></span><h2><a class="toc-backref" href="#id176">Mathematical Functions and Type Coercion</a><a class="headerlink" href="#module-vigra.ufunc" title="Permalink to this headline">¶</a></h2>
<p>Vigra images and volumes support all arithmetic and algebraic functions defined in
<a class="reference external" href="http://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs">numpy.ufunc</a>.</p>
<p>The following mathematical functions are available in this module:</p>
<div class="highlight-python"><pre>absolute   absolute   add   arccos   arccosh   arcsin   arcsinh
arctan   arctan2   arctanh   bitwise_and   bitwise_or   bitwise_xor   ceil
conjugate   conjugate   cos   cosh   deg2rad   degrees   divide
equal   exp   exp2   expm1   fabs   floor   floor_divide
fmax   fmin   fmod   frexp   greater   greater_equal   hypot
invert   invert   isfinite   isinf   isnan   ldexp   left_shift
less   less_equal   log   log10   log1p   logaddexp   logaddexp2
logical_and   logical_not   logical_or   logical_xor   maximum   minimum   modf
multiply   negative   not_equal   ones_like   power   rad2deg   radians
reciprocal   remainder   remainder   right_shift   rint   sign   signbit
sin   sinh   sqrt   square   subtract   tan   tanh
true_divide   trunc</pre>
</div>
<p>Some of these functions are also provided as member functions of the vigra array types:</p>
<div class="highlight-python"><pre>__abs__   __add__   __and__   __div__   __divmod__   __eq__   __floordiv__
__ge__   __gt__   __invert__   __le__   __lshift__   __lt__   __mod__
__mul__   __ne__   __neg__   __or__   __pos__   __pow__   __radd__
__radd__   __rand__   __rdiv__   __rdivmod__   __rfloordiv__   __rlshift__
__rmod__   __rmul__   __ror__   __rpow__   __rrshift__   __rshift__
__rsub__   __rtruediv__   __rxor__   __sub__   __truediv__   __xor__</pre>
</div>
<p>As usual, these functions are applied independently at each pixel.
Vigranumpy overloads the numpy-versions of these functions in order to make their
behavior more suitable for image analysis. In particular, we changed two aspects:</p>
<ul class="simple">
<li>The memory layout of the input arrays is preserved in the result arrays.
In contrast, plain numpy.ufuncs always create C-order arrays, even if
the inputs have a different order (e.g. as Fortran-order).</li>
<li>The value types of result arrays (i.e. their &#8216;dtype&#8217;) are determined in a way
that is more suitable for image processing than the original numpy conversion rules.</li>
</ul>
<p>Array dtype conversion (aka coercion) is implemented by the function
vigra.ufunc.Function.common_type according to the following coercion rules:</p>
<dl class="method">
<dt id="vigra.ufunc.Function.common_type">
<tt class="descclassname">Function.</tt><tt class="descname">common_type</tt><big>(</big><em>in_type</em>, <em>out_type</em><big>)</big><a class="headerlink" href="#vigra.ufunc.Function.common_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Find the appropriate pair (in_dtype, out_dtype) according to 
vigranumpy typecasting rules. in_dtype is the type into which 
the arguments will be casted before performing the operation
(to prevent possible overflow), out_type is the type the output
array will have (unless an explicit out-argument is provided).</p>
<p>The ideas behind the vigranumpy typcasting rules are (i) to represent
data with at most 32 bit, when possible, (ii) to reduce the number of
types that occur as results of mixed expressions, and (iii) to minimize 
the chance of bad surprises. Default output types are thus determined 
according to the following rules:</p>
<ol class="arabic">
<li><p class="first">The output type does not depend on the order of the arguments:</p>
<div class="highlight-python"><pre>a + b results in the same type as b + a</pre>
</div>
</li>
<li><p class="first">With exception of logical functions and abs(), the output type 
does not depend on the function to be executed. The output type 
of logical functions is bool. The output type of abs() follows
general rules unless the input is complex, in which case the
output type is the corresponding float type:</p>
<div class="highlight-python"><pre>a + b results in the same type as a / b
a == b =&gt; bool
abs(complex128) =&gt; float64</pre>
</div>
</li>
<li><p class="first">If the inputs have the same type, the type is preserved:</p>
<div class="highlight-python"><pre>uint8 + uint8 =&gt; uint8</pre>
</div>
</li>
<li><p class="first">If (and only if) one of the inputs has at least 64 bits, the output 
will also have at least 64 bits:</p>
<div class="highlight-python"><pre>int64 + uint32 =&gt; int64
int64 + 1.0    =&gt; float64</pre>
</div>
</li>
<li><p class="first">If an array is combined with a scalar of the same kind (integer,
float, or complex), the array type is preserved. If an integer 
array with at most 32 bits is combined with a float scalar, the 
result is float32 (and rule 4 kicks in if the array has 64 bits):</p>
<div class="highlight-python"><pre>uint8   + 1   =&gt; uint8
uint8   + 1.0 =&gt; float32
float32 + 1.0 =&gt; float32
float64 + 1.0 =&gt; float64</pre>
</div>
</li>
<li><p class="first">Integer expressions with mixed types always produce signed results.
If the arguments have at most 32 bits, the result will be int32, 
otherwise it will be int64 (cf. rule 4):</p>
<div class="highlight-python"><pre>int8  + uint8  =&gt; int32
int32 + uint8  =&gt; int32
int32 + uint32 =&gt; int32
int32 + int64  =&gt; int64
int64 + uint64 =&gt; int64</pre>
</div>
</li>
<li><p class="first">In all other cases, the output type is equal to the highest input 
type:</p>
<div class="highlight-python"><pre>int32   + float32    =&gt; float32
float32 + complex128 =&gt; complex128</pre>
</div>
</li>
<li><p class="first">All defaults can be overridden by providing an explicit output array:</p>
<div class="highlight-python"><pre>ufunc.add(uint8, uint8, uint16) =&gt; uint16</pre>
</div>
<p>In order to prevent overflow, necessary upcasting is performed before 
the function is executed.</p>
</li>
</ol>
</dd></dl>

</div>
<div class="section" id="module-vigra.colors">
<h2><a class="toc-backref" href="#id177">Color and Intensity Manipulation</a><a class="headerlink" href="#module-vigra.colors" title="Permalink to this headline">¶</a></h2>
<p>The module vigra.colors provides functions to adjust image brightness and contrast,
and to transform between different color spaces.
See <a class="reference external" href="../vigra/group__ColorConversions.html">Color Conversions</a> in the C++ documentation
for more information.</p>
<dl class="function">
<dt id="vigra.colors.brightness">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">brightness</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.brightness" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>brightness( (object)image, (float)factor [, (object)range=(0.0, 255.0) [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Adjust the brightness of an image or volume. The function applies the formula:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">out</span> <span class="o">=</span> <span class="n">image</span> <span class="o">+</span> <span class="mf">0.25</span> <span class="o">*</span> <span class="n">log</span><span class="p">(</span><span class="n">factor</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="nb">range</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">-</span> <span class="nb">range</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
</pre></div>
</div>
<p>to each element of the array. &#8216;factor&#8217; and &#8216;range[1] - range[0]&#8217; must be positive. Elements outside the given range are clipped at the range borders. If &#8216;range&#8217; is None or &#8220;&#8221; or &#8220;auto&#8221;, the range is set to the actual range of &#8216;image&#8217;:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nb">range</span> <span class="o">=</span> <span class="n">image</span><span class="o">.</span><span class="n">min</span><span class="p">(),</span> <span class="n">image</span><span class="o">.</span><span class="n">max</span><span class="p">()</span>
</pre></div>
</div>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray brightness(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
<p>brightness( (object)volume, (float)factor [, (object)range=(0.0, 255.0) [, (object)out=None]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray brightness(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.contrast">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">contrast</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.contrast" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>contrast( (object)image, (float)factor [, (object)range=(0.0, 255.0) [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Adjust the contrast of an image or volume. The function applies the formula:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">out</span> <span class="o">=</span> <span class="n">factor</span> <span class="o">*</span> <span class="n">image</span> <span class="o">+</span> <span class="p">(</span><span class="mf">1.0</span> <span class="o">-</span> <span class="n">factor</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="nb">range</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">-</span> <span class="nb">range</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">/</span> <span class="mf">2.0</span>
</pre></div>
</div>
<p>to each element of the array. &#8216;factor&#8217; and &#8216;range[1] - range[0]&#8217; must be positive. Elements outside the given range are clipped at the range borders. If &#8216;range&#8217; is None or &#8220;&#8221; or &#8220;auto&#8221;, the range is set to the actual range of &#8216;image&#8217;:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nb">range</span> <span class="o">=</span> <span class="n">image</span><span class="o">.</span><span class="n">min</span><span class="p">(),</span> <span class="n">image</span><span class="o">.</span><span class="n">max</span><span class="p">()</span>
</pre></div>
</div>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray contrast(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
<p>contrast( (object)volume, (float)factor [, (object)range=(0.0, 255.0) [, (object)out=None]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray contrast(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.gammaCorrection">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">gammaCorrection</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.gammaCorrection" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>gammaCorrection( (object)image, (float)factor [, (object)range=(0.0, 255.0) [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Adjust gamma correction to an image or volume. The function applies the formula:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">diff</span> <span class="o">=</span> <span class="nb">range</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">-</span> <span class="nb">range</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="n">out</span> <span class="o">=</span> <span class="nb">pow</span><span class="p">((</span><span class="n">image</span> <span class="o">-</span> <span class="nb">range</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">/</span> <span class="n">diff</span><span class="p">,</span> <span class="mf">1.0</span> <span class="o">/</span> <span class="n">gamma</span><span class="p">)</span> <span class="o">*</span> <span class="n">diff</span> <span class="o">+</span> <span class="nb">range</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</pre></div>
</div>
<p>to each element of the array. &#8216;factor&#8217; and &#8216;range[1] - range[0]&#8217; must be positive. Elements outside the given range are clipped at the range borders. If &#8216;range&#8217; is None or &#8220;&#8221; or &#8220;auto&#8221;, the range is set to the actual range of &#8216;image&#8217;:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nb">range</span> <span class="o">=</span> <span class="n">image</span><span class="o">.</span><span class="n">min</span><span class="p">(),</span> <span class="n">image</span><span class="o">.</span><span class="n">max</span><span class="p">()</span>
</pre></div>
</div>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gammaCorrection(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
<p>gammaCorrection( (object)volume, (float)factor [, (object)range=(0.0, 255.0) [, (object)out=None]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gammaCorrection(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.linearRangeMapping">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">linearRangeMapping</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.linearRangeMapping" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>linearRangeMapping( (object)image [, (object)oldRange=&#8217;auto&#8217; [, (object)newRange=(0.0, 255.0) [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Convert the intensity range of an image or volume. The function applies a linear transformation to the intensities such that the value oldRange[0] is mapped onto newRange[0], and oldRange[1] is mapped onto newRange[1]. That is, the algorithm applies the formula:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">oldDiff</span> <span class="o">=</span> <span class="n">oldRange</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">-</span> <span class="n">oldRange</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="n">newDiff</span> <span class="o">=</span> <span class="n">newRange</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">-</span> <span class="n">newRange</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="n">out</span> <span class="o">=</span> <span class="p">(</span><span class="n">image</span> <span class="o">-</span> <span class="n">oldRange</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">/</span> <span class="n">oldDiff</span> <span class="o">*</span> <span class="n">newDiff</span> <span class="o">+</span> <span class="n">newRange</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</pre></div>
</div>
<p>to each element of the array. &#8216;oldDiff&#8217; and &#8216;newDiff&#8217; must be positive. If &#8216;oldRange&#8217; is None or &#8220;&#8221; or &#8220;auto&#8221; (the default), the range is set to the actual range of &#8216;image&#8217;:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nb">range</span> <span class="o">=</span> <span class="n">image</span><span class="o">.</span><span class="n">min</span><span class="p">(),</span> <span class="n">image</span><span class="o">.</span><span class="n">max</span><span class="p">()</span>
</pre></div>
</div>
<p>If &#8216;newRange&#8217; is None or &#8220;&#8221; or &#8220;auto&#8221;, it is set to (0, 255.0).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray linearRangeMapping(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=&#8217;auto&#8217; [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
<p>linearRangeMapping( (object)image [, (object)oldRange=&#8217;auto&#8217; [, (object)newRange=(0.0, 255.0) [, (object)out=None]]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray linearRangeMapping(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=&#8217;auto&#8217; [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</blockquote>
<p>linearRangeMapping( (object)volume [, (object)oldRange=&#8217;auto&#8217; [, (object)newRange=(0.0, 255.0) [, (object)out=None]]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray linearRangeMapping(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=&#8217;auto&#8217; [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</blockquote>
<p>linearRangeMapping( (object)volume [, (object)oldRange=&#8217;auto&#8217; [, (object)newRange=(0.0, 255.0) [, (object)out=None]]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray linearRangeMapping(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=&#8217;auto&#8217; [,class boost::python::api::object=(0.0, 255.0) [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_Lab2RGB">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_Lab2RGB</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_Lab2RGB" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_Lab2RGB( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using Lab2RGBFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1Lab2RGBFunctor.html">Lab2RGBFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_Lab2RGB(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_Lab2RGBPrime">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_Lab2RGBPrime</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_Lab2RGBPrime" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_Lab2RGBPrime( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using Lab2RGBPrimeFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1Lab2RGBPrimeFunctor.html">Lab2RGBPrimeFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_Lab2RGBPrime(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_Lab2XYZ">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_Lab2XYZ</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_Lab2XYZ" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_Lab2XYZ( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using Lab2XYZFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1Lab2XYZFunctor.html">Lab2XYZFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_Lab2XYZ(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_Luv2RGB">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_Luv2RGB</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_Luv2RGB" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_Luv2RGB( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using Luv2RGBFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1Luv2RGBFunctor.html">Luv2RGBFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_Luv2RGB(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_Luv2RGBPrime">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_Luv2RGBPrime</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_Luv2RGBPrime" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_Luv2RGBPrime( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using Luv2RGBPrimeFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1Luv2RGBPrimeFunctor.html">Luv2RGBPrimeFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_Luv2RGBPrime(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_Luv2XYZ">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_Luv2XYZ</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_Luv2XYZ" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_Luv2XYZ( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using Luv2XYZFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1Luv2XYZFunctor.html">Luv2XYZFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_Luv2XYZ(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGB2Lab">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGB2Lab</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGB2Lab" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGB2Lab( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGB2LabFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGB2LabFunctor.html">RGB2LabFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGB2Lab(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGB2Luv">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGB2Luv</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGB2Luv" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGB2Luv( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGB2LuvFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGB2LuvFunctor.html">RGB2LuvFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGB2Luv(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGB2RGBPrime">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGB2RGBPrime</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGB2RGBPrime" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGB2RGBPrime( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGB2RGBPrimeFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGB2RGBPrimeFunctor.html">RGB2RGBPrimeFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGB2RGBPrime(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGB2XYZ">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGB2XYZ</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGB2XYZ" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGB2XYZ( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGB2XYZFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGB2XYZFunctor.html">RGB2XYZFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGB2XYZ(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGB2sRGB">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGB2sRGB</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGB2sRGB" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGB2sRGB( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGB2sRGBFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGB2sRGBFunctor.html">RGB2sRGBFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGB2sRGB(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGBPrime2Lab">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGBPrime2Lab</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGBPrime2Lab" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGBPrime2Lab( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGBPrime2LabFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGBPrime2LabFunctor.html">RGBPrime2LabFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGBPrime2Lab(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGBPrime2Luv">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGBPrime2Luv</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGBPrime2Luv" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGBPrime2Luv( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGBPrime2LuvFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGBPrime2LuvFunctor.html">RGBPrime2LuvFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGBPrime2Luv(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGBPrime2RGB">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGBPrime2RGB</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGBPrime2RGB" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGBPrime2RGB( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGBPrime2RGBFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGBPrime2RGBFunctor.html">RGBPrime2RGBFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGBPrime2RGB(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGBPrime2XYZ">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGBPrime2XYZ</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGBPrime2XYZ" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGBPrime2XYZ( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGBPrime2XYZFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGBPrime2XYZFunctor.html">RGBPrime2XYZFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGBPrime2XYZ(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGBPrime2YPrimeCbCr">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGBPrime2YPrimeCbCr</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGBPrime2YPrimeCbCr" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGBPrime2YPrimeCbCr( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGBPrime2YPrimeCbCrFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGBPrime2YPrimeCbCrFunctor.html">RGBPrime2YPrimeCbCrFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGBPrime2YPrimeCbCr(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGBPrime2YPrimeIQ">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGBPrime2YPrimeIQ</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGBPrime2YPrimeIQ" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGBPrime2YPrimeIQ( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGBPrime2YPrimeIQFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGBPrime2YPrimeIQFunctor.html">RGBPrime2YPrimeIQFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGBPrime2YPrimeIQ(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGBPrime2YPrimePbPr">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGBPrime2YPrimePbPr</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGBPrime2YPrimePbPr" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGBPrime2YPrimePbPr( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGBPrime2YPrimePbPrFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGBPrime2YPrimePbPrFunctor.html">RGBPrime2YPrimePbPrFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGBPrime2YPrimePbPr(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_RGBPrime2YPrimeUV">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_RGBPrime2YPrimeUV</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_RGBPrime2YPrimeUV" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_RGBPrime2YPrimeUV( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using RGBPrime2YPrimeUVFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1RGBPrime2YPrimeUVFunctor.html">RGBPrime2YPrimeUVFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_RGBPrime2YPrimeUV(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_XYZ2Lab">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_XYZ2Lab</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_XYZ2Lab" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_XYZ2Lab( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using XYZ2LabFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1XYZ2LabFunctor.html">XYZ2LabFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_XYZ2Lab(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_XYZ2Luv">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_XYZ2Luv</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_XYZ2Luv" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_XYZ2Luv( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using XYZ2LuvFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1XYZ2LuvFunctor.html">XYZ2LuvFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_XYZ2Luv(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_XYZ2RGB">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_XYZ2RGB</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_XYZ2RGB" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_XYZ2RGB( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using XYZ2RGBFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1XYZ2RGBFunctor.html">XYZ2RGBFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_XYZ2RGB(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_XYZ2RGBPrime">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_XYZ2RGBPrime</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_XYZ2RGBPrime" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_XYZ2RGBPrime( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using XYZ2RGBPrimeFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1XYZ2RGBPrimeFunctor.html">XYZ2RGBPrimeFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_XYZ2RGBPrime(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_YPrimeCbCr2RGBPrime">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_YPrimeCbCr2RGBPrime</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_YPrimeCbCr2RGBPrime" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_YPrimeCbCr2RGBPrime( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using YPrimeCbCr2RGBPrimeFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1YPrimeCbCr2RGBPrimeFunctor.html">YPrimeCbCr2RGBPrimeFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_YPrimeCbCr2RGBPrime(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_YPrimeIQ2RGBPrime">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_YPrimeIQ2RGBPrime</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_YPrimeIQ2RGBPrime" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_YPrimeIQ2RGBPrime( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using YPrimeIQ2RGBPrimeFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1YPrimeIQ2RGBPrimeFunctor.html">YPrimeIQ2RGBPrimeFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_YPrimeIQ2RGBPrime(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_YPrimePbPr2RGBPrime">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_YPrimePbPr2RGBPrime</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_YPrimePbPr2RGBPrime" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_YPrimePbPr2RGBPrime( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using YPrimePbPr2RGBPrimeFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1YPrimePbPr2RGBPrimeFunctor.html">YPrimePbPr2RGBPrimeFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_YPrimePbPr2RGBPrime(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_YPrimeUV2RGBPrime">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_YPrimeUV2RGBPrime</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_YPrimeUV2RGBPrime" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_YPrimeUV2RGBPrime( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using YPrimeUV2RGBPrimeFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1YPrimeUV2RGBPrimeFunctor.html">YPrimeUV2RGBPrimeFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_YPrimeUV2RGBPrime(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.colors.transform_sRGB2RGB">
<tt class="descclassname">vigra.colors.</tt><tt class="descname">transform_sRGB2RGB</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.colors.transform_sRGB2RGB" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>transform_sRGB2RGB( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convert the colors of the given &#8216;image&#8217; using sRGB2RGBFunctor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/classvigra_1_1sRGB2RGBFunctor.html">sRGB2RGBFunctor</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray transform_sRGB2RGB(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

</div>
<div class="section" id="module-vigra.filters">
<h2><a class="toc-backref" href="#id178">Filters</a><a class="headerlink" href="#module-vigra.filters" title="Permalink to this headline">¶</a></h2>
<p>The module vigra.filters provides operators that consider a window around each pixel, compute
one or several numbers from the values in the window, and store the results in the
corresponding pixel of the output image. This includes convolution, non-linear diffusion,
morphological operators, feature detectors (such as the structure tensor) etc.</p>
<dl class="class">
<dt id="vigra.filters.Kernel1D">
<em class="property">class </em><tt class="descclassname">vigra.filters.</tt><tt class="descname">Kernel1D</tt><a class="headerlink" href="#vigra.filters.Kernel1D" title="Permalink to this definition">¶</a></dt>
<dd><p>Generic 1 dimensional convolution kernel.</p>
<p>This kernel may be used for convolution of 1 dimensional signals or for separable convolution of multidimensional signals. The kernel&#8217;s size is given by its left() and right() methods. The desired border treatment mode is returned by getBorderTreatment(). The different init functions create a kernel with the specified properties. For more details, see <a class="reference external" href="../../doc/vigra/classvigra_1_1Kernel1D.html">Kernel1D</a> in the C++ documentation.</p>
<dl class="docutils">
<dt>__init__( (object)arg1) -&gt; None :</dt>
<dd><p class="first">Standard constructor:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">Kernel1D</span><span class="p">()</span>
</pre></div>
</div>
<p>Creates an identity kernel.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void __init__(struct _object <a href="#id112"><span class="problematic" id="id113">*</span></a>)</dd>
</dl>
</dd>
<dt>__init__( (object)arg1, (Kernel1D)kernel) -&gt; None :</dt>
<dd><p class="first">Copy constructor:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">Kernel1D</span><span class="p">(</span><span class="n">other_kernel</span><span class="p">)</span>
</pre></div>
</div>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void __init__(struct _object <a href="#id114"><span class="problematic" id="id115">*</span></a>,class vigra::Kernel1D&lt;double&gt;)</dd>
</dl>
</dd>
</dl>
<dl class="method">
<dt id="vigra.filters.Kernel1D.borderTreatment">
<tt class="descname">borderTreatment</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.borderTreatment" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>borderTreatment( (Kernel1D)arg1) -&gt; BorderTreatmentMode :</dt>
<dd><p class="first">Return current border treatment mode.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>enum vigra::BorderTreatmentMode borderTreatment(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initAveraging">
<tt class="descname">initAveraging</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initAveraging" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initAveraging( (Kernel1D)arg1, (int)radius [, (float)norm=1.0]) -&gt; None :</dt>
<dd><p class="first">Init kernel as an averaging filter with given radius (i.e. window size 2*radius+1). &#8216;norm&#8217; denotes the sum of all bins of the kernel.</p>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;averagingKernel()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initAveraging(class vigra::Kernel1D&lt;double&gt; {lvalue},int [,double=1.0])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initBinomial">
<tt class="descname">initBinomial</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initBinomial" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initBinomial( (Kernel1D)arg1, (int)radius [, (float)norm=1.0]) -&gt; None :</dt>
<dd><p class="first">Init kernel as a binomial filter with given radius (i.e. window size 2*radius+1). &#8216;norm&#8217; denotes the sum of all bins of the kernel.</p>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;binomialKernel()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initBinomial(class vigra::Kernel1D&lt;double&gt; {lvalue},int [,double=1.0])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initBurtFilter">
<tt class="descname">initBurtFilter</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initBurtFilter" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initBurtFilter( (Kernel1D)arg1 [, (float)a=0.047849999999999997]) -&gt; None :</dt>
<dd><p class="first">Init kernel as a 5-tap smoothing filter of the form:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="p">[</span> <span class="n">a</span><span class="p">,</span> <span class="mf">0.25</span><span class="p">,</span> <span class="mf">0.5</span> <span class="o">-</span> <span class="mi">2</span><span class="o">*</span><span class="n">a</span><span class="p">,</span> <span class="mf">0.25</span><span class="p">,</span> <span class="n">a</span><span class="p">]</span>
</pre></div>
</div>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;burtFilterKernel()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initBurtFilter(class vigra::Kernel1D&lt;double&gt; {lvalue} [,double=0.047849999999999997])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initDiscreteGaussian">
<tt class="descname">initDiscreteGaussian</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initDiscreteGaussian" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initDiscreteGaussian( (Kernel1D)arg1, (float)scale [, (float)norm=1.0]) -&gt; None :</dt>
<dd><p class="first">Init kernel as Lindeberg&#8217;s discrete analog of the Gaussian function. The radius of the kernel is always 3*std_dev. &#8216;norm&#8217; denotes the desired sum of all bins of the kernel.</p>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;discreteGaussianKernel()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initDiscreteGaussian(class vigra::Kernel1D&lt;double&gt; {lvalue},double [,double=1.0])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initExplicitly">
<tt class="descname">initExplicitly</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initExplicitly" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initExplicitly( (Kernel1D)arg1, (int)left, (int)right, (object)contents) -&gt; None :</dt>
<dd><p class="first">Init the kernel with explicit values from &#8216;contents&#8217;, which must be a 1D numpy.ndarray. &#8216;left&#8217; and &#8216;right&#8217; are the boundaries of the kernel (inclusive). If &#8216;contents&#8217; contains the wrong number of values, a run-time error results. It is, however, possible to give just one initializer. This creates an averaging filter with the given constant. The norm is set to the sum of the initializer values.</p>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;explicitlyKernel()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initExplicitly(class vigra::Kernel1D&lt;double&gt; {lvalue},int,int,class vigra::NumpyArray&lt;1,double,struct vigra::StridedArrayTag&gt;)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initGaussian">
<tt class="descname">initGaussian</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initGaussian" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initGaussian( (Kernel1D)arg1, (float)scale [, (float)norm=1.0]) -&gt; None :</dt>
<dd><p class="first">Init kernel as a sampled Gaussian function. The radius of the kernel is always 3*std_dev. &#8216;norm&#8217; denotes the desired sum of all bins of the kernel (i.e. the kernel is corrected for the normalization error introduced by windowing the Gaussian to a finite interval). However, if norm is 0.0, the kernel is normalized to 1 by the analytic expression for the Gaussian, and no correction for the windowing error is performed.</p>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;gaussianKernel()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initGaussian(class vigra::Kernel1D&lt;double&gt; {lvalue},double [,double=1.0])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initGaussianDerivative">
<tt class="descname">initGaussianDerivative</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initGaussianDerivative" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initGaussianDerivative( (Kernel1D)arg1, (float)scale, (int)order [, (float)norm=1.0]) -&gt; None :</dt>
<dd><p class="first">Init kernel as a Gaussian derivative of order &#8216;order&#8217;. The radius of the kernel is always 3*std_dev + 0.5*order. &#8216;norm&#8217; denotes the norm of the kernel. Thus, the kernel will be corrected for the error introduced by windowing the Gaussian to a finite interval. However, if norm is 0.0, the kernel is normalized to 1 by the analytic expression for the Gaussian derivative, and no correction for the windowing error is performed.</p>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;gaussianDerivativeKernel()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initGaussianDerivative(class vigra::Kernel1D&lt;double&gt; {lvalue},double,int [,double=1.0])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initOptimalFirstDerivative5">
<tt class="descname">initOptimalFirstDerivative5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initOptimalFirstDerivative5" title="Permalink to this definition">¶</a></dt>
<dd><p>initOptimalFirstDerivative5( (Kernel1D)arg1) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void initOptimalFirstDerivative5(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initOptimalFirstDerivativeSmoothing3">
<tt class="descname">initOptimalFirstDerivativeSmoothing3</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initOptimalFirstDerivativeSmoothing3" title="Permalink to this definition">¶</a></dt>
<dd><p>initOptimalFirstDerivativeSmoothing3( (Kernel1D)arg1) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void initOptimalFirstDerivativeSmoothing3(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initOptimalFirstDerivativeSmoothing5">
<tt class="descname">initOptimalFirstDerivativeSmoothing5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initOptimalFirstDerivativeSmoothing5" title="Permalink to this definition">¶</a></dt>
<dd><p>initOptimalFirstDerivativeSmoothing5( (Kernel1D)arg1) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void initOptimalFirstDerivativeSmoothing5(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initOptimalSecondDerivative5">
<tt class="descname">initOptimalSecondDerivative5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initOptimalSecondDerivative5" title="Permalink to this definition">¶</a></dt>
<dd><p>initOptimalSecondDerivative5( (Kernel1D)arg1) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void initOptimalSecondDerivative5(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initOptimalSecondDerivativeSmoothing3">
<tt class="descname">initOptimalSecondDerivativeSmoothing3</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initOptimalSecondDerivativeSmoothing3" title="Permalink to this definition">¶</a></dt>
<dd><p>initOptimalSecondDerivativeSmoothing3( (Kernel1D)arg1) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void initOptimalSecondDerivativeSmoothing3(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initOptimalSecondDerivativeSmoothing5">
<tt class="descname">initOptimalSecondDerivativeSmoothing5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initOptimalSecondDerivativeSmoothing5" title="Permalink to this definition">¶</a></dt>
<dd><p>initOptimalSecondDerivativeSmoothing5( (Kernel1D)arg1) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void initOptimalSecondDerivativeSmoothing5(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initOptimalSmoothing3">
<tt class="descname">initOptimalSmoothing3</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initOptimalSmoothing3" title="Permalink to this definition">¶</a></dt>
<dd><p>initOptimalSmoothing3( (Kernel1D)arg1) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void initOptimalSmoothing3(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initOptimalSmoothing5">
<tt class="descname">initOptimalSmoothing5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initOptimalSmoothing5" title="Permalink to this definition">¶</a></dt>
<dd><p>initOptimalSmoothing5( (Kernel1D)arg1) -&gt; None :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void initOptimalSmoothing5(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initSecondDifference3">
<tt class="descname">initSecondDifference3</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initSecondDifference3" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initSecondDifference3( (Kernel1D)arg1) -&gt; None :</dt>
<dd><p class="first">Init kernel as a 3-tap second difference filter of the form:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="p">[</span> <span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
</pre></div>
</div>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;secondDifference3Kernel()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initSecondDifference3(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.initSymmetricDifference">
<tt class="descname">initSymmetricDifference</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.initSymmetricDifference" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initSymmetricDifference( (Kernel1D)arg1 [, (float)norm=1.0]) -&gt; None :</dt>
<dd><p class="first">Init kernel as a symmetric difference filter of the form:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="p">[</span> <span class="mf">0.5</span> <span class="o">*</span> <span class="n">norm</span><span class="p">,</span> <span class="mf">0.0</span> <span class="o">*</span> <span class="n">norm</span><span class="p">,</span> <span class="o">-</span><span class="mf">0.5</span> <span class="o">*</span> <span class="n">norm</span><span class="p">]</span>
</pre></div>
</div>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;symmetricDifferenceKernel()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initSymmetricDifference(class vigra::Kernel1D&lt;double&gt; {lvalue} [,double=1.0])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.left">
<tt class="descname">left</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.left" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>left( (Kernel1D)arg1) -&gt; int :</dt>
<dd><p class="first">Left border of kernel (inclusive).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int left(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.norm">
<tt class="descname">norm</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.norm" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>norm( (Kernel1D)arg1) -&gt; float :</dt>
<dd><p class="first">Return the norm of kernel.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>double norm(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.normalize">
<tt class="descname">normalize</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.normalize" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>normalize( (Kernel1D)arg1 [, (float)norm=1.0 [, (int)derivativeOrder=0 [, (float)offset=0.0]]]) -&gt; None :</dt>
<dd><p class="first">Set a new norm and normalize kernel, use the normalization formula for the given derivativeOrder.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void normalize(class vigra::Kernel1D&lt;double&gt; {lvalue} [,double=1.0 [,unsigned int=0 [,double=0.0]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.right">
<tt class="descname">right</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.right" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>right( (Kernel1D)arg1) -&gt; int :</dt>
<dd><p class="first">Right border of kernel (inclusive).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int right(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.setBorderTreatment">
<tt class="descname">setBorderTreatment</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.setBorderTreatment" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>setBorderTreatment( (Kernel1D)arg1, (BorderTreatmentMode)borderTreatment) -&gt; None :</dt>
<dd><p class="first">Set border treatment mode.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void setBorderTreatment(class vigra::Kernel1D&lt;double&gt; {lvalue},enum vigra::BorderTreatmentMode)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel1D.size">
<tt class="descname">size</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel1D.size" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>size( (Kernel1D)arg1) -&gt; int :</dt>
<dd><p class="first">Number of kernel elements (right() - left() + 1).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int size(class vigra::Kernel1D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="vigra.filters.Kernel2D">
<em class="property">class </em><tt class="descclassname">vigra.filters.</tt><tt class="descname">Kernel2D</tt><a class="headerlink" href="#vigra.filters.Kernel2D" title="Permalink to this definition">¶</a></dt>
<dd><p>Generic 2 dimensional convolution kernel.</p>
<p>This kernel may be used for convolution of 2 dimensional signals. The desired border treatment mode is returned by borderTreatment().(Note that the 2D convolution functions don&#8217;t currently support all modes.) The different init functions create a kernel with the specified properties. For more details, see <a class="reference external" href="../../doc/vigra/classvigra_1_1Kernel2D.html">Kernel2D</a> in the C++ documentation.</p>
<dl class="docutils">
<dt>__init__( (object)arg1) -&gt; None :</dt>
<dd><p class="first">Standard constructor:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">Kernel2D</span><span class="p">()</span>
</pre></div>
</div>
<p>Creates an identity kernel.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void __init__(struct _object <a href="#id116"><span class="problematic" id="id117">*</span></a>)</dd>
</dl>
</dd>
<dt>__init__( (object)arg1, (Kernel2D)kernel) -&gt; None :</dt>
<dd><p class="first">Copy constructor:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">Kernel2D</span><span class="p">(</span><span class="n">other_kernel</span><span class="p">)</span>
</pre></div>
</div>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void __init__(struct _object <a href="#id118"><span class="problematic" id="id119">*</span></a>,class vigra::Kernel2D&lt;double&gt;)</dd>
</dl>
</dd>
</dl>
<dl class="method">
<dt id="vigra.filters.Kernel2D.borderTreatment">
<tt class="descname">borderTreatment</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.borderTreatment" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>borderTreatment( (Kernel2D)arg1) -&gt; BorderTreatmentMode :</dt>
<dd><p class="first">Return current border treatment mode.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>enum vigra::BorderTreatmentMode borderTreatment(class vigra::Kernel2D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.height">
<tt class="descname">height</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.height" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>height( (Kernel2D)arg1) -&gt; int :</dt>
<dd><p class="first">Vertical kernel size (lowerRight()[1] - upperLeft()[1] + 1).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int height(class vigra::Kernel2D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.initDisk">
<tt class="descname">initDisk</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.initDisk" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initDisk( (Kernel2D)arg1, (int)radius) -&gt; None :</dt>
<dd><p class="first">Init the 2D kernel as a circular averaging filter. The norm will be calculated as 1 / (number of non-zero kernel values).</p>
<p>Precondition:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">radius</span> <span class="o">&gt;</span> <span class="mi">0</span>
</pre></div>
</div>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;diskKernel2D()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initDisk(class vigra::Kernel2D&lt;double&gt; {lvalue},int)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.initExplicitly">
<tt class="descname">initExplicitly</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.initExplicitly" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initExplicitly( (Kernel2D)arg1, (object)upperLeft, (object)lowerRight, (object)contents) -&gt; None :</dt>
<dd><p class="first">Init the kernel with explicit values from &#8216;contents&#8217;, which must be a 2D numpy.ndarray. &#8216;upperLeft&#8217; and &#8216;lowerRight&#8217; are the boundaries of the kernel (inclusive), and  must be 2D tuples. If &#8216;contents&#8217; contains the wrong number of values, a run-time error results. It is, however, possible to give just one initializer. This creates an averaging filter with the given constant. The norm is set to the sum of the initializer values.</p>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;explicitlyKernel2D()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initExplicitly(class vigra::Kernel2D&lt;double&gt; {lvalue},class vigra::TinyVector&lt;int,2&gt;,class vigra::TinyVector&lt;int,2&gt;,class vigra::NumpyArray&lt;2,double,struct vigra::StridedArrayTag&gt;)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.initGaussian">
<tt class="descname">initGaussian</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.initGaussian" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initGaussian( (Kernel2D)arg1, (float)scale [, (float)norm=1.0]) -&gt; None :</dt>
<dd><p class="first">Init kernel as a sampled 2D Gaussian function. The radius of the kernel is always 3*std_dev. &#8216;norm&#8217; denotes the desired sum of all bins of the kernel (i.e. the kernel is corrected for the normalization error introduced by windowing the Gaussian to a finite interval). However, if norm is 0.0, the kernel is normalized to 1 by the analytic expression for the Gaussian, and no correction for the windowing error is performed.</p>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;gaussianKernel2D()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initGaussian(class vigra::Kernel2D&lt;double&gt; {lvalue},double [,double=1.0])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.initSeparable">
<tt class="descname">initSeparable</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.initSeparable" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>initSeparable( (Kernel2D)arg1, (Kernel1D)kernelX, (Kernel1D)kernelY) -&gt; None :</dt>
<dd><p class="first">Init the 2D kernel as the cartesian product of two 1D kernels of type Kernel1D. The norm becomes the product of the two original norms.</p>
<p>Kernel construction and initialization can be performed in one step by calling the factory function &#8216;separableKernel2D()&#8217;.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void initSeparable(class vigra::Kernel2D&lt;double&gt; {lvalue},class vigra::Kernel1D&lt;double&gt;,class vigra::Kernel1D&lt;double&gt;)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.lowerRight">
<tt class="descname">lowerRight</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.lowerRight" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>lowerRight( (Kernel2D)arg1) -&gt; object :</dt>
<dd><p class="first">Lower right border of kernel (inclusive).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::Point2D lowerRight(class vigra::Kernel2D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.norm">
<tt class="descname">norm</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.norm" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>norm( (Kernel2D)arg1) -&gt; float :</dt>
<dd><p class="first">Return the norm of the kernel.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>double norm(class vigra::Kernel2D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.normalize">
<tt class="descname">normalize</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.normalize" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>normalize( (Kernel2D)arg1 [, (float)norm=1.0]) -&gt; None :</dt>
<dd><p class="first">Set the kernel&#8217;s norm and renormalize the values.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void normalize(class vigra::Kernel2D&lt;double&gt; {lvalue} [,double=1.0])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.setBorderTreatment">
<tt class="descname">setBorderTreatment</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.setBorderTreatment" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>setBorderTreatment( (Kernel2D)arg1, (BorderTreatmentMode)borderTreatment) -&gt; None :</dt>
<dd><p class="first">Set border treatment mode.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void setBorderTreatment(class vigra::Kernel2D&lt;double&gt; {lvalue},enum vigra::BorderTreatmentMode)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.upperLeft">
<tt class="descname">upperLeft</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.upperLeft" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>upperLeft( (Kernel2D)arg1) -&gt; object :</dt>
<dd><p class="first">Upper left border of kernel (inclusive).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::Point2D upperLeft(class vigra::Kernel2D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.filters.Kernel2D.width">
<tt class="descname">width</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.Kernel2D.width" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>width( (Kernel2D)arg1) -&gt; int :</dt>
<dd><p class="first">Horizontal kernel size (lowerRight()[0] - upperLeft()[0] + 1).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int width(class vigra::Kernel2D&lt;double&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

</dd></dl>

<dl class="function">
<dt id="vigra.filters.boundaryTensor2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">boundaryTensor2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.boundaryTensor2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>boundaryTensor2D( (object)image, (float)scale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate the boundary tensor for a scalar valued 2D image.For details see <a class="reference external" href="../../doc/vigra/group__TensorImaging.html#g3f60d75d3f938c3805544c28e5aa0053">boundaryTensor</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray boundaryTensor2D(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.convolve">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">convolve</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.convolve" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>convolve( (object)image, (Kernel1D)kernel [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convolve an image or volume with the given &#8216;kernel&#8217; (or kernels).
If the input has multiple channels, the filter is applied to each channel
independently. The function can be used in 3 different ways:</p>
<ul class="simple">
<li>When &#8216;kernel&#8217; is a single object of type <a title="vigra.filters.Kernel1D" class="reference internal" href="#vigra.filters.Kernel1D"><tt class="xref docutils literal"><span class="pre">Kernel1D</span></tt></a>, this kernel
is applied along all spatial dimensions of the data (separable filtering).</li>
<li>When &#8216;kernel&#8217; is a tuple of <a title="vigra.filters.Kernel1D" class="reference internal" href="#vigra.filters.Kernel1D"><tt class="xref docutils literal"><span class="pre">Kernel1D</span></tt></a> objects, one different kernel
is used for each spatial dimension (separable filtering). The number of
kernels must equal the number of dimensions).</li>
<li>When &#8216;kernel&#8217; is an instance of <a title="vigra.filters.Kernel2D" class="reference internal" href="#vigra.filters.Kernel2D"><tt class="xref docutils literal"><span class="pre">Kernel2D</span></tt></a>, a 2-dimensional convolution
is performed (non-separable filtering). This is only applicable to 2D images.</li>
</ul>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayConvolutionFilters.html#g7245a227c77d8d91c99e4fcd68fbad7d">separableConvolveMultiArray</a> and <a class="reference external" href="../../doc/vigra/group__StandardConvolution.html#gc147d74c0f049bb206e264dd8baed2fc">convolveImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray convolve(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class vigra::Kernel1D&lt;double&gt; [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>convolve( (object)volume, (Kernel1D)kernel [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray convolve(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class vigra::Kernel1D&lt;double&gt; [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>convolve( (object)image, (tuple)kernels [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray convolve(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class boost::python::tuple [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>convolve( (object)volume, (tuple)kernels [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray convolve(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class boost::python::tuple [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>convolve( (object)image, (Kernel2D)kernel [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray convolve(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class vigra::Kernel2D&lt;double&gt; [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.convolveOneDimension">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">convolveOneDimension</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.convolveOneDimension" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>convolveOneDimension( (object)image, (int)dim, (Kernel1D)kernel [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Convolution along a single dimension of a 2D or 3D scalar or multiband image. &#8216;kernel&#8217; must be an instance of Kernel1D.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayConvolutionFilters.html#g28ecfad8f9bf2f5bbb9b700195d19247">convolveMultiArrayOneDimension</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray convolveOneDimension(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,unsigned int,class vigra::Kernel1D&lt;double&gt; [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>convolveOneDimension( (object)volume, (int)dim, (Kernel1D)kernel [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray convolveOneDimension(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,unsigned int,class vigra::Kernel1D&lt;double&gt; [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.discClosing">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">discClosing</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.discClosing" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>discClosing( (object)image, (int)radius [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Apply a closing filter with disc of given radius to image.</p>
<p>This is an abbreviation for applying a dilation and an erosion  filter in sequence. This function also works for multiband images, it is then executed on every band.</p>
<p>See <a class="reference external" href="../../doc/vigra/group__Morphology.html#g9ad9e1341cba5796d7e62e980d416bf3">discRankOrderFilter</a> in the C++ documentation for more information.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray discClosing(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,int [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.discDilation">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">discDilation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.discDilation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>discDilation( (object)image, (int)radius [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Apply dilation (maximum) filter with disc of given radius to image.</p>
<p>This is an abbreviation for the rank order filter with rank = 1.0. This function also works for multiband images, it is then executed on every band.</p>
<p>See <a class="reference external" href="../../doc/vigra/group__Morphology.html#g19cc1cd5de821b98767a0bcf8e73297d">discDilation</a> in the C++ documentation for more information.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray discDilation(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,int [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.discErosion">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">discErosion</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.discErosion" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>discErosion( (object)image, (int)radius [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Apply erosion (minimum) filter with disc of given radius to image.</p>
<p>This is an abbreviation for the rank order filter with rank = 0.0. This function also works for multiband images, it is then executed on every band.</p>
<p>See <a class="reference external" href="../../doc/vigra/group__Morphology.html#ga2d1b9ffb9e104cb1f62d45c4340393a">discErosion</a> in the C++ documentation for more information.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray discErosion(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,int [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.discMedian">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">discMedian</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.discMedian" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>discMedian( (object)image, (int)radius [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Apply median filter with disc of given radius to image.</p>
<p>This is an abbreviation for the rank order filter with rank = 0.5. This function also works for multiband images, it is then executed on every band.</p>
<p>See <a class="reference external" href="../../doc/vigra/group__Morphology.html#g46692ed77dda507e7bdf817720640467">discMedian</a> in the C++ documentation for more information.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray discMedian(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,int [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.discOpening">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">discOpening</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.discOpening" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>discOpening( (object)image, (int)radius [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Apply a opening filter with disc of given radius to image.</p>
<p>This is an abbreviation for applying an erosion and a dilation filter in sequence. This function also works for multiband images, it is then executed on every band.</p>
<p>See <a class="reference external" href="../../doc/vigra/group__Morphology.html#g9ad9e1341cba5796d7e62e980d416bf3">discRankOrderFilter</a> in the C++ documentation for more information.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray discOpening(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,int [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.discRankOrderFilter">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">discRankOrderFilter</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.discRankOrderFilter" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>discRankOrderFilter( (object)image, (int)radius, (float)rank [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Apply rank order filter with disc structuring function to the image.</p>
<p>The pixel values of the source image  must be in the range 0...255. Radius must be &gt;= 0. Rank must be in the range 0.0 &lt;= rank &lt;= 1.0. The filter acts as a minimum filter if rank = 0.0, as a median if rank = 0.5, and as a maximum filter if rank = 1.0. This function also works for multiband images, it is then executed on every band.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__Morphology.html#g9ad9e1341cba5796d7e62e980d416bf3">discRankOrderFilter</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray discRankOrderFilter(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,int,float [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>discRankOrderFilter( (object)image, (int)radius, (float)rank [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray discRankOrderFilter(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,int,float [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.discRankOrderFilterWithMask">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">discRankOrderFilterWithMask</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.discRankOrderFilterWithMask" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>discRankOrderFilterWithMask( (object)image, (object)mask, (int)radius, (float)rank [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Apply rank order filter with disc structuring function to the image using a mask.</p>
<p>The pixel values of the source image must be in the range 0...255. Radius must be &gt;= 0.Rank must be in the range 0.0 &lt;= rank &lt;= 1.0. The filter acts as a minimum filter if rank = 0.0,as a median if rank = 0.5, and as a maximum filter if rank = 1.0.</p>
<p>The mask is only applied to the input image, i.e. the function generates an output wherever the current disc contains at least one pixel with non-zero mask value. Source pixels with mask value zero are ignored during the calculation of the rank order.</p>
<p>This function also works for multiband images, it is then executed on every band. If the mask has only one band, it is used for every image band. If the mask has the same number of bands, as the image the bands are used for the corresponding image bands.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__Morphology.html#ga6f578a4ec22fc0bcce2c8416a9d004b">discRankOrderFilterWithMask</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray discRankOrderFilterWithMask(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,int,float [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>discRankOrderFilterWithMask( (object)image, (object)mask, (int)radius, (float)rank [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray discRankOrderFilterWithMask(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,int,float [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.distanceTransform2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">distanceTransform2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.distanceTransform2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>distanceTransform2D( (object)image [, (float)background=0 [, (int)norm=2 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">For all background pixels, calculate the distance to the nearest object or contour. The label of the pixels to be considered background in the source image is passed in the parameter &#8216;background&#8217;. Source pixels with other labels will be considered objects. In the destination image, all pixels corresponding to background will be assigned the their distance value, all pixels corresponding to objects will be assigned 0.</p>
<p>The &#8216;norm&#8217; parameter gives the distance norm to use.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__DistanceTransform.html#g4c3a954c8547e2b63c342e234a1f695d">distanceTransform</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray distanceTransform2D(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,float=0 [,int=2 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
<p>distanceTransform2D( (object)image [, (int)background=0 [, (int)norm=2 [, (object)out=None]]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray distanceTransform2D(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt; [,unsigned char=0 [,int=2 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.distanceTransform3D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">distanceTransform3D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.distanceTransform3D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>distanceTransform3D( (object)array, (float)background [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">For all background voxels, calculate the distance to the nearest object or contour.The label of the voxels to be considered background in the source volume is passed in the parameter &#8216;background&#8217;. Source voxels with other labels will be considered objects. In the destination volume, all voxels corresponding to background will be assigned their distance value, all voxels corresponding to objects will be assigned 0.</p>
<p>For more details see <a class="reference external" href="../../doc/vigra/group__MultiArrayDistanceTransform.html#g9747dd24226b4a01f81255e4299200e6">separableMultiDistance</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray distanceTransform3D(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,float [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.gaussianGradient">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">gaussianGradient</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.gaussianGradient" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>gaussianGradient( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate the gradient vector by means of a 1st derivative of Gaussian filter at the given scale for a 2D or 3D scalar image.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayConvolutionFilters.html#g2da85c26a08c9fba7e7a44ffcd981e7a">gaussianGradientMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gaussianGradient(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,2&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>gaussianGradient( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gaussianGradient(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.gaussianGradientMagnitude">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">gaussianGradientMagnitude</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.gaussianGradientMagnitude" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>gaussianGradientMagnitude( (object)image, (float)sigma [, (bool)accumulate=True [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Calculate the gradient magnitude by means of a 1st derivative of Gaussian filter at the given scale for a 2D or 3D scalar or multiband image.
If &#8216;accumulate&#8217; is True (the default), the gradients are accumulated (in the L2-norm sense) over all  channels of a multi-channel array. Otherwise, a separate gradient magnitude is computed for each channel.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayConvolutionFilters.html#g2da85c26a08c9fba7e7a44ffcd981e7a">gaussianGradientMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gaussianGradientMagnitude(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,bool=True [,class vigra::NumpyAnyArray=None]])</dd>
</dl>
</dd>
</dl>
<p>gaussianGradientMagnitude( (object)volume, (float)sigma [, (bool)accumulate=True [, (object)out=None]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gaussianGradientMagnitude(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,bool=True [,class vigra::NumpyAnyArray=None]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.gaussianSharpening2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">gaussianSharpening2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.gaussianSharpening2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>gaussianSharpening2D( (object)image [, (float)sharpeningFactor=1.0 [, (float)scale=1.0 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Perform sharpening function with gaussian filter.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__CommonConvolutionFilters.html#g4f33702febc6e06af6952b39e949595f">gaussianSharpening</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gaussianSharpening2D(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,double=1.0 [,double=1.0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.gaussianSmoothing">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">gaussianSmoothing</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.gaussianSmoothing" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>gaussianSmoothing( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Perform Gaussian smoothing of a 2D or 3D scalar or multiband image.</p>
<p>Each channel of the array is smoothed independently. If &#8216;sigma&#8217; is a single value, an isotropic Gaussian filter at this scale is applied (i.e. each dimension is smoothed in the same way). If &#8216;sigma&#8217; is a tuple of values, the amount of smoothing will be different for each spatial dimension. The length of the tuple must be equal to the number of spatial dimensions.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__CommonConvolutionFilters.html#g6fd5a8bb3d262ec36eebb5d001fbf227">gaussianSmoothing</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gaussianSmoothing(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>gaussianSmoothing( (object)volume, (tuple)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gaussianSmoothing(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class boost::python::tuple [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>gaussianSmoothing( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gaussianSmoothing(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>gaussianSmoothing( (object)volume, (tuple)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray gaussianSmoothing(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class boost::python::tuple [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.hessianOfGaussian">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">hessianOfGaussian</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.hessianOfGaussian" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>hessianOfGaussian( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate the Hessian matrix by means of a derivative of Gaussian filters at the given scale for a 2D or 3D scalar image.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayConvolutionFilters.html#ged0e09fbccfc82dab434a92efef75c47">hessianOfGaussianMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray hessianOfGaussian(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,1&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>hessianOfGaussian( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray hessianOfGaussian(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.hessianOfGaussianEigenvalues">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">hessianOfGaussianEigenvalues</tt><big>(</big><em>image</em>, <em>scale</em>, <em>out=None</em><big>)</big><a class="headerlink" href="#vigra.filters.hessianOfGaussianEigenvalues" title="Permalink to this definition">¶</a></dt>
<dd><p>Compute the eigenvalues of the Hessian of Gaussian at the given scale
for a scalar image or volume.</p>
<p>Calls <a title="vigra.filters.hessianOfGaussian" class="reference internal" href="#vigra.filters.hessianOfGaussian"><tt class="xref docutils literal"><span class="pre">hessianOfGaussian()</span></tt></a> and <a title="vigra.filters.tensorEigenvalues" class="reference internal" href="#vigra.filters.tensorEigenvalues"><tt class="xref docutils literal"><span class="pre">tensorEigenvalues()</span></tt></a>.</p>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.hourGlassFilter2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">hourGlassFilter2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.hourGlassFilter2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>hourGlassFilter2D( (object)image, (float)sigma, (float)rho [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Anisotropic tensor smoothing with the hourglass filter.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__TensorImaging.html#gfc744b33345f5ed70eb6ab035f803de0">hourGlassFilter</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray hourGlassFilter2D(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;,double,double [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.laplacianOfGaussian">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">laplacianOfGaussian</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.laplacianOfGaussian" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>laplacianOfGaussian( (object)image [, (float)scale=1.0 [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Filter scalar image or volume with the Laplacian of Gaussian operator at the given scale.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayConvolutionFilters.html#g51e2e8f9db9959f33401fc0927f27f31">laplacianOfGaussianMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray laplacianOfGaussian(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,double=1.0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
<p>laplacianOfGaussian( (object)volume [, (float)scale=1.0 [, (object)out=None]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray laplacianOfGaussian(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,double=1.0 [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.multiBinaryClosing">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">multiBinaryClosing</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.multiBinaryClosing" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>multiBinaryClosing( (object)image, (float)radius [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Binary closing on multi-dimensional arrays.</p>
<p>This function applies a flat circular opening operator (sequential dilation and erosion) with a given radius. The operation is isotropic. The input is a uint8 or boolean multi-dimensional array where non-zero pixels represent foreground and zero pixels represent background. This function also works for multiband arrays, it is then executed on every band.</p>
<p>For details see vigra C++ documentation (<a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#gd7820cd163794f11b6f192c260294832">multiBinaryDilation</a> and <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#g64403c83bc660bc431960076dcb2c9d9">multiBinaryErosion</a>).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiBinaryClosing(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>multiBinaryClosing( (object)image, (float)radius [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiBinaryClosing(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;bool&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;bool&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.multiBinaryDilation">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">multiBinaryDilation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.multiBinaryDilation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>multiBinaryDilation( (object)image, (float)radius [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Binary dilation on multi-dimensional arrays.</p>
<p>This function applies a flat circular dilation operator with a given radius. The operation is isotropic. The input is a uint8 or boolean multi-dimensional array where non-zero pixels represent foreground and zero pixels represent background. This function also works for multiband arrays, it is then executed on every band.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#gd7820cd163794f11b6f192c260294832">multiBinaryDilation</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiBinaryDilation(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>multiBinaryDilation( (object)image, (float)radius [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiBinaryDilation(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;bool&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;bool&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.multiBinaryErosion">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">multiBinaryErosion</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.multiBinaryErosion" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>multiBinaryErosion( (object)image, (float)radius [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Binary erosion on multi-dimensional arrays.</p>
<p>This function applies a flat circular erosion operator with a given radius. The operation is isotropic. The input is a uint8 or boolean multi-dimensional array where non-zero pixels represent foreground and zero pixels represent background. This function also works for multiband arrays, it is then executed on every band.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#g64403c83bc660bc431960076dcb2c9d9">multiBinaryErosion</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiBinaryErosion(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>multiBinaryErosion( (object)image, (float)radius [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiBinaryErosion(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;bool&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;bool&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.multiBinaryOpening">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">multiBinaryOpening</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.multiBinaryOpening" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>multiBinaryOpening( (object)image, (float)radius [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Binary opening on multi-dimensional arrays.</p>
<p>This function applies a flat circular opening operator (sequential erosion and dilation) with a given radius. The operation is isotropic. The input is a uint8 or boolean multi-dimensional array where non-zero pixels represent foreground and zero pixels represent background. This function also works for multiband arrays, it is then executed on every band.</p>
<p>For details see vigra C++ documentation (<a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#gd7820cd163794f11b6f192c260294832">multiBinaryDilation</a> and <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#g64403c83bc660bc431960076dcb2c9d9">multiBinaryErosion</a>).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiBinaryOpening(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>multiBinaryOpening( (object)image, (float)radius [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiBinaryOpening(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;bool&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;bool&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.multiGrayscaleClosing">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">multiGrayscaleClosing</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.multiGrayscaleClosing" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>multiGrayscaleClosing( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Parabolic grayscale closing on multi-dimensional arrays.</p>
<p>This function applies a parabolic closing (sequential dilation and erosion) operator with a given spread &#8216;sigma&#8217; on a grayscale array. The operation is isotropic. The input is a grayscale multi-dimensional array. This function also works for multiband arrays, it is then executed on every band.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#g6afd77ad5ca52a86172f7b8244e36ca5">multiGrayscaleDilation</a> and <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#g6968f67ec56d75b3bfcf49be6a7b7957">multiGrayscaleErosion</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleClosing(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>multiGrayscaleClosing( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleClosing(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>multiGrayscaleClosing( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleClosing(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>multiGrayscaleClosing( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleClosing(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.multiGrayscaleDilation">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">multiGrayscaleDilation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.multiGrayscaleDilation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>multiGrayscaleDilation( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Parabolic grayscale dilation on multi-dimensional arrays.</p>
<p>This function applies a parabolic dilation operator with a given spread &#8216;sigma&#8217; on a grayscale array. The operation is isotropic. The input is a grayscale multi-dimensional array. This function also works for multiband arrays, it is then executed on every band.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#g6afd77ad5ca52a86172f7b8244e36ca5">multiGrayscaleDilation</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleDilation(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>multiGrayscaleDilation( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleDilation(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>multiGrayscaleDilation( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleDilation(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>multiGrayscaleDilation( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleDilation(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.multiGrayscaleErosion">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">multiGrayscaleErosion</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.multiGrayscaleErosion" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>multiGrayscaleErosion( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Parabolic grayscale erosion on multi-dimensional arrays.</p>
<p>This function applies a parabolic erosion operator with a given spread &#8216;sigma&#8217; on a grayscale array. The operation is isotropic. The input is a grayscale multi-dimensional array. This function also works for multiband arrays, it is then executed on every band.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#g6968f67ec56d75b3bfcf49be6a7b7957">multiGrayscaleErosion</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleErosion(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>multiGrayscaleErosion( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleErosion(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>multiGrayscaleErosion( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleErosion(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>multiGrayscaleErosion( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleErosion(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.multiGrayscaleOpening">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">multiGrayscaleOpening</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.multiGrayscaleOpening" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>multiGrayscaleOpening( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Parabolic grayscale opening on multi-dimensional arrays.</p>
<p>This function applies a parabolic opening (sequential erosion and dilation) operator with a given spread &#8216;sigma&#8217; on a grayscale array. The operation is isotropic. The input is a grayscale multi-dimensional array. This function also works for multiband arrays, it is then executed on every band.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#g6afd77ad5ca52a86172f7b8244e36ca5">multiGrayscaleDilation</a> and <a class="reference external" href="../../doc/vigra/group__MultiArrayMorphology.html#g6968f67ec56d75b3bfcf49be6a7b7957">multiGrayscaleErosion</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleOpening(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>multiGrayscaleOpening( (object)volume, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleOpening(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>multiGrayscaleOpening( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleOpening(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>multiGrayscaleOpening( (object)image, (float)sigma [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray multiGrayscaleOpening(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.nonlinearDiffusion">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">nonlinearDiffusion</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.nonlinearDiffusion" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>nonlinearDiffusion( (object)arg1, (float)image, (float)edgeThreshold, (object)scale) -&gt; object :</dt>
<dd><p class="first">Perform edge-preserving smoothing at the given scale.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__NonLinearDiffusion.html#g9dbd0f3b85ce44ba56362624d0e2e02f">nonlinearDiffusion</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray nonlinearDiffusion(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.normalizedConvolveImage">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">normalizedConvolveImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.normalizedConvolveImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>normalizedConvolveImage( (object)image, (object)mask, (Kernel2D)kernel [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Perform normalized convolution of an image. If the image has multiple channels, every channel is convolved independently. The &#8216;mask&#8217; tells the algorithm whether input pixels are valid (non-zero mask value) or not. Invalid pixels are ignored in the convolution. The mask must have one channel (which is then used for all channels input channels) or as many channels as the input image.</p>
<p>For details, see <a class="reference external" href="../../doc/vigra/group__StandardConvolution.html#gda968281f4992ffb636914bb4545ff87">normalizedConvolveImage</a> in the C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray normalizedConvolveImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,class vigra::Kernel2D&lt;double&gt; [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.radialSymmetryTransform2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">radialSymmetryTransform2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.radialSymmetryTransform2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>radialSymmetryTransform2D( (object)image, (float)scale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Find centers of radial symmetry in an 2D image.</p>
<p>This algorithm implements the Fast Radial Symmetry Transform according to [G. Loy, A. Zelinsky: &#8220;A Fast Radial Symmetry Transform for Detecting Points of Interest&#8221;, in: A. Heyden et al. (Eds.): Proc. of 7th European Conf. on Computer Vision, Part 1, pp. 358-368, Springer LNCS 2350, 2002]</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__SymmetryDetection.html#g7a8a9b508efabb4105fb044c3cc5d597">radialSymmetryTransform</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray radialSymmetryTransform2D(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.recursiveFilter2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">recursiveFilter2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.recursiveFilter2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>recursiveFilter2D( (object)image, (float)b [, (BorderTreatmentMode)borderTreament=vigra.filters.BorderTreatmentMode.BORDER_TREATMENT_REFLECT [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Perform 2D convolution with a first-order recursive filter with parameter &#8216;b&#8217; and given &#8216;borderTreatment&#8217;. &#8216;b&#8217; must be between -1 and 1.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__RecursiveConvolution.html#g87b63aec49b44039ab4b9e2c0a575503">recursiveFilterX</a> and <a class="reference external" href="../../doc/vigra/group__RecursiveConvolution.html#g14d0fcd368e5fb71503f7e4effef3bab">recursiveFilterY</a> (which this function calls in succession) in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray recursiveFilter2D(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,enum vigra::BorderTreatmentMode=vigra.filters.BorderTreatmentMode.BORDER_TREATMENT_REFLECT [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
<dt>recursiveFilter2D( (object)image, (float)b1, (float)b2 [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Perform 2D convolution with a second-order recursive filter with parameters &#8216;b1&#8217; and &#8216;b2&#8217;. Border treatment is always BORDER_TREATMENT_REFLECT.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__RecursiveConvolution.html#g87b63aec49b44039ab4b9e2c0a575503">recursiveFilterX</a> and <a class="reference external" href="../../doc/vigra/group__RecursiveConvolution.html#g14d0fcd368e5fb71503f7e4effef3bab">recursiveFilterY</a> (which this function calls in succession) in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray recursiveFilter2D(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.recursiveGradient2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">recursiveGradient2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.recursiveGradient2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>recursiveGradient2D( (object)arg1, (float)image, (BorderTreatmentMode)scale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Compute the gradient of a scalar image using a recursive (exponential) filter at the given &#8216;scale&#8217;. The output image (if given) must have two channels.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__RecursiveConvolution.html#g28b7db13e97c7d7d9a5c270a125d7d5a">recursiveSmoothLine</a> and <a class="reference external" href="../../doc/vigra/group__RecursiveConvolution.html#g4cd050f29b566f306cbd968bdd5923bc">recursiveFirstDerivativeLine</a> (which this function calls internally) in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray recursiveGradient2D(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,enum vigra::BorderTreatmentMode [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.recursiveLaplacian2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">recursiveLaplacian2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.recursiveLaplacian2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>recursiveLaplacian2D( (object)image, (float)scale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Compute the gradient of a 2D scalar or multiband image using a recursive (exponential) filter at the given &#8216;scale&#8217;. The output image (if given) must have as many channels as the input.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__RecursiveConvolution.html#g28b7db13e97c7d7d9a5c270a125d7d5a">recursiveSmoothLine</a> and <a class="reference external" href="../../doc/vigra/group__RecursiveConvolution.html#gc7f3e23c8702e7aecc42cb843dc3552b">recursiveSecondDerivativeLine</a> (which this function calls internally) in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray recursiveLaplacian2D(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.recursiveSmooth2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">recursiveSmooth2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.recursiveSmooth2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>recursiveSmooth2D( (object)image, (float)scale [, (BorderTreatmentMode)borderTreament=vigra.filters.BorderTreatmentMode.BORDER_TREATMENT_REFLECT [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Calls recursiveFilter2D() with b = exp(-1/scale), which corresponds to smoothing with an exponential filter exp(-abs(x)/scale).</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__RecursiveConvolution.html#g28b7db13e97c7d7d9a5c270a125d7d5a">recursiveSmoothLine</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray recursiveSmooth2D(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,enum vigra::BorderTreatmentMode=vigra.filters.BorderTreatmentMode.BORDER_TREATMENT_REFLECT [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.rieszTransformOfLOG2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">rieszTransformOfLOG2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.rieszTransformOfLOG2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>rieszTransformOfLOG2D( (object)image, (float)scale, (int)xorder, (int)yorder [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate Riesz transforms of the Laplacian of Gaussian.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__CommonConvolutionFilters.html#g067b2f50f0b34ee834d93c71a2a1f056">rieszTransformOfLOG</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray rieszTransformOfLOG2D(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,unsigned int,unsigned int [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.simpleSharpening2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">simpleSharpening2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.simpleSharpening2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>simpleSharpening2D( (object)image [, (float)sharpeningFactor=1.0 [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Perform simple sharpening function.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__CommonConvolutionFilters.html#ga6b4a4e379356b608f63a2eab3674b0a">simpleSharpening</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray simpleSharpening2D(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,double=1.0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.structureTensor">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">structureTensor</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.structureTensor" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>structureTensor( (object)image, (float)innerScale, (float)outerScale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate the structure tensor of an image or volume by means of Gaussian (derivative) filters at the given scales. If the input has multiple channels, the structure tensors of each channel are added to get the result.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayConvolutionFilters.html#ge65b9ecee8460303144fc03ea2580d0e">structureTensorMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray structureTensor(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>structureTensor( (object)volume, (float)innerScale, (float)outerScale [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray structureTensor(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double [,class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,6&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.structureTensorEigenvalues">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">structureTensorEigenvalues</tt><big>(</big><em>image</em>, <em>innerScale</em>, <em>outerScale</em>, <em>out=None</em><big>)</big><a class="headerlink" href="#vigra.filters.structureTensorEigenvalues" title="Permalink to this definition">¶</a></dt>
<dd><p>Compute the eigenvalues of the structure tensor at the given scales
for a scalar or multi-channel image or volume.</p>
<p>Calls <a title="vigra.filters.structureTensor" class="reference internal" href="#vigra.filters.structureTensor"><tt class="xref docutils literal"><span class="pre">structureTensor()</span></tt></a> and <a title="vigra.filters.tensorEigenvalues" class="reference internal" href="#vigra.filters.tensorEigenvalues"><tt class="xref docutils literal"><span class="pre">tensorEigenvalues()</span></tt></a>.</p>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.symmetricGradient">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">symmetricGradient</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.symmetricGradient" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>symmetricGradient( (object)arg1, (float)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate gradient of a scalar 2D image or 3D volume using symmetric difference filters.
For details see <a class="reference external" href="../../doc/vigra/group__MultiArrayConvolutionFilters.html#g62814e9cd26b8aab742bb87d5e0e75d9">symmetricGradientMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray symmetricGradient(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,2&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>symmetricGradient( (object)arg1, (float)volume [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray symmetricGradient(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.tensorDeterminant">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">tensorDeterminant</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.tensorDeterminant" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>tensorDeterminant( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate the determinant of a 2x2 or 3x3 tensor image.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiPointoperators.html#g3e3b942b5eded9011ff6f9048fd02d36">tensorDeterminantMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray tensorDeterminant(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>tensorDeterminant( (object)volume [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray tensorDeterminant(class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,6&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.tensorEigenRepresentation2D">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">tensorEigenRepresentation2D</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.tensorEigenRepresentation2D" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>tensorEigenRepresentation2D( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate eigen representation of a symmetric 2x2 tensor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__TensorImaging.html#gda3e358fe5b3958d47d231b29989a974">tensorEigenRepresentation</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray tensorEigenRepresentation2D(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.tensorEigenvalues">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">tensorEigenvalues</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.tensorEigenvalues" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>tensorEigenvalues( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate the eigenvalues in each pixel/voxel of a 2x2 or 3x3 tensor image.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiPointoperators.html#g9f437d7a3c9619bccc3d4b8c0b85de4f">tensorEigenvaluesMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray tensorEigenvalues(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,2&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>tensorEigenvalues( (object)volume [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray tensorEigenvalues(class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,6&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.tensorTrace">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">tensorTrace</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.tensorTrace" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>tensorTrace( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Calculate the trace of a 2x2 or 3x3 tensor image.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiPointoperators.html#g864b023582cffea27dbc3a6325bf635e">tensorTraceMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray tensorTrace(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>tensorTrace( (object)volume [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray tensorTrace(class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,6&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.filters.vectorToTensor">
<tt class="descclassname">vigra.filters.</tt><tt class="descname">vectorToTensor</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.filters.vectorToTensor" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>vectorToTensor( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Turn a 2D or 3D vector valued image (e.g. the gradient image) into a tensor image by computing the outer product in every pixel.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__MultiPointoperators.html#g929c7e28dae11811c094a0c43f48520b">vectorToTensorMultiArray</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray vectorToTensor(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,2&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>vectorToTensor( (object)volume [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray vectorToTensor(class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,3&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;3,class vigra::TinyVector&lt;float,6&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

</div>
<div class="section" id="module-vigra.sampling">
<h2><a class="toc-backref" href="#id179">Sampling</a><a class="headerlink" href="#module-vigra.sampling" title="Permalink to this headline">¶</a></h2>
<p>The module vigra.sampling contains methods to change the number and/or location of
the image sampling points, such as resizing, rotation, and interpolation.</p>
<dl class="function">
<dt id="vigra.sampling.resampleImage">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">resampleImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.resampleImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>resampleImage( (object)image, (float)factor [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Resample an image by the given &#8216;factor&#8217;</p>
<p>The &#8216;out&#8217; parameter must have, if given, the according dimensions.
This function also works for multiband images, it is then executed on every band.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#g68e08f25b220b037fd59313fde70ffc9">resampleImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resampleImage(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.resamplingGaussian">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">resamplingGaussian</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.resamplingGaussian" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>resamplingGaussian( (object)image [, (float)sigmaX=1.0 [, (int)derivativeOrderX=0 [, (float)samplingRatioX=2.0 [, (float)offsetX=0.0 [, (float)sigmaY=1.0 [, (int)derivativeOrderY=0 [, (float)samplingRatioY=2.0 [, (float)offsetY=0.0 [, (object)out=None]]]]]]]]]) -&gt; object :</dt>
<dd><p class="first">Resample image using a gaussian filter:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">resamplingGaussian</span><span class="p">(</span><span class="n">image</span><span class="p">,</span>
                   <span class="n">sigmaX</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span> <span class="n">derivativeOrderX</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">samplingRatioX</span><span class="o">=</span><span class="mf">2.0</span><span class="p">,</span> <span class="n">offsetX</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span>
                   <span class="n">sigmaY</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span> <span class="n">derivativeOrderY</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">samplingRatioY</span><span class="o">=</span><span class="mf">2.0</span><span class="p">,</span> <span class="n">offsetY</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span>
                   <span class="n">out</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
</pre></div>
</div>
<p>This function utilizes <a class="reference external" href="../../doc/vigra/group__ResamplingConvolutionFilters.html#g4a52df2a11c33ca42fa74664678177c8">resamplingConvolveImage</a> with a Gaussianfilter
(see the vigra C++ documentation for details).</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resamplingGaussian(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,double=1.0 [,unsigned int=0 [,double=2.0 [,double=0.0 [,double=1.0 [,unsigned int=0 [,double=2.0 [,double=0.0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]]]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.resize">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">resize</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.resize" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>resize( (object)image [, (object)shape=None [, (int)order=3 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Resize image or volume using B-spline interpolation.</p>
<p>The spline order is given in the parameter &#8216;order&#8217;.
The desired shape of the output array is taken either from &#8216;shape&#8217; or &#8216;out&#8217;.
If both are given, they must agree. This function also works for multi-channel data, it is then executed on every channel independently.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#g02f1c9007ec9b0395accc6b02ea37284">resizeImageSplineInterpolation</a> and <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#gd77190b060bafe5791f7926502f147ec">resizeMultiArraySplineInterpolation</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resize(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=None [,int=3 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
<p>resize( (object)image [, (object)shape=None [, (int)order=3 [, (object)out=None]]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resize(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=None [,int=3 [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.resizeImageCatmullRomInterpolation">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">resizeImageCatmullRomInterpolation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.resizeImageCatmullRomInterpolation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>resizeImageCatmullRomInterpolation( (object)image [, (object)shape=None [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Resize image using the Catmull/Rom interpolation function.</p>
<p>The desired shape of the output image is taken either from &#8216;shape&#8217; or &#8216;out&#8217;.
If both are given, they must agree.
This function also works for multiband images, it is then executed on every band.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#g4fe762871977ae7f4b29fc78ea411edc">resizeImageCatmullRomInterpolation</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resizeImageCatmullRomInterpolation(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=None [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.resizeImageCoscotInterpolation">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">resizeImageCoscotInterpolation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.resizeImageCoscotInterpolation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>resizeImageCoscotInterpolation( (object)image [, (object)shape=None [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Resize image using the Coscot interpolation function.</p>
<p>The desired shape of the output image is taken either from &#8216;shape&#8217; or &#8216;out&#8217;.
If both are given, they must agree.
This function also works for multiband images, it is then executed on every band.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#gb4955d622ab2f110a7e5c72d0d27b59a">resizeImageCoscotInterpolation</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resizeImageCoscotInterpolation(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=None [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.resizeImageLinearInterpolation">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">resizeImageLinearInterpolation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.resizeImageLinearInterpolation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>resizeImageLinearInterpolation( (object)image [, (object)shape=None [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Resize image using linear interpolation.
The function uses the standard separable bilinear interpolation algorithm to obtain a good compromise between quality and speed.</p>
<p>The desired shape of the output image is taken either from &#8216;shape&#8217; or &#8216;out&#8217;.
If both are given, they must agree.
This function also works for multiband images, it is then executed on every band.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#gdc90ce771db3f4b57fe6d3135592f74c">resizeImageLinearInterpolation</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resizeImageLinearInterpolation(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=None [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.resizeImageNoInterpolation">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">resizeImageNoInterpolation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.resizeImageNoInterpolation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>resizeImageNoInterpolation( (object)image [, (object)shape=None [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Resize image by repeating the nearest pixel values.</p>
<p>The desired shape of the output image is taken either from &#8216;shape&#8217; or &#8216;out&#8217;.
If both are given, they must agree.
This function also works for multiband images, it is then executed on every band.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#g8db7c21dc1a3b3f5a7b4e8619345626b">resizeImageNoInterpolation</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resizeImageNoInterpolation(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=None [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.resizeImageSplineInterpolation">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">resizeImageSplineInterpolation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.resizeImageSplineInterpolation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>resizeImageSplineInterpolation( (object)image [, (object)shape=None [, (int)order=3 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Resize image using B-spline interpolation.</p>
<p>The spline order is given in the parameter &#8216;order&#8217;.
The desired shape of the output image is taken either from &#8216;shape&#8217; or &#8216;out&#8217;.
If both are given, they must agree.
This function also works for multiband images, it is then executed on every band.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#g02f1c9007ec9b0395accc6b02ea37284">resizeImageSplineInterpolation</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resizeImageSplineInterpolation(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=None [,int=3 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.resizeVolumeSplineInterpolation">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">resizeVolumeSplineInterpolation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.resizeVolumeSplineInterpolation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>resizeVolumeSplineInterpolation( (object)image [, (object)shape=None [, (int)order=3 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Resize volume using B-spline interpolation.</p>
<p>The spline order is given in the parameter &#8216;order&#8217;.
The dimensions of the output volume is taken either from &#8216;shape&#8217; or &#8216;out&#8217;.
If both are given, they must agree.
This function also works for multiband volumes, it is then executed on every band.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#gd77190b060bafe5791f7926502f147ec">resizeMultiArraySplineInterpolation</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray resizeVolumeSplineInterpolation(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,class boost::python::api::object=None [,int=3 [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.rotateImageDegree">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">rotateImageDegree</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.rotateImageDegree" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>rotateImageDegree( (object)image, (float)degree [, (RotationDirection)direction=vigra.sampling.RotationDirection.CLOCKWISE [, (int)splineOrder=0 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Rotate an image by an arbitrary angle using splines for interpolation around its center.</p>
<p>The angle may be given in degree (parameter degree).
The parameter &#8216;splineOrder&#8217; indicates the order of the splines used for interpolation.
If the &#8216;out&#8217; parameter is given, the image is cropped for it&#8217;s dimensions. If the &#8216;out&#8217;
parameter is not given, an output image with the same dimensions as the input image is created.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#gc5db2aa94b116d3cc1b67b96e4ac96b5">GeometricTransformations.rotationMatrix2DDegrees</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray rotateImageDegree(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,enum vigra::RotationDirection=vigra.sampling.RotationDirection.CLOCKWISE [,int=0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.rotateImageRadiant">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">rotateImageRadiant</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.rotateImageRadiant" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>rotateImageRadiant( (object)image, (float)radiant [, (RotationDirection)direction=vigra.sampling.RotationDirection.CLOCKWISE [, (int)splineOrder=0 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Rotate an image by an arbitrary angle around its center using splines for interpolation.</p>
<p>The angle may be given in radiant (parameter radiant).
The parameter &#8216;splineOrder&#8217; indicates the order of the splines used for interpolation.
If the &#8216;out&#8217; parameter is given, the image is cropped for it&#8217;s dimensions. If the &#8216;out&#8217;
parameter is not given, an output image with the same dimensions as the input image is created.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#gfdb14c737ca2c1587eeb2ac7d040542e">GeometricTransformations.rotationMatrix2DRadians</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray rotateImageRadiant(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,enum vigra::RotationDirection=vigra.sampling.RotationDirection.CLOCKWISE [,int=0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.sampling.rotateImageSimple">
<tt class="descclassname">vigra.sampling.</tt><tt class="descname">rotateImageSimple</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.rotateImageSimple" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>rotateImageSimple( (object)image [, (RotationDirection)orientation=vigra.sampling.RotationDirection.CLOCKWISE [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Rotate an image by a multiple of 90 degrees.</p>
<p>The &#8216;orientation&#8217; parameter (which must be one of CLOCKWISE, COUNTER_CLOCKWISE and UPSIDE_DOWN
indicates the rotation direction. The &#8216;out&#8217; parameter must, if given, have the according dimensions.
This function also works for multiband images, it is then executed on every band.</p>
<p>For more details, see <a class="reference external" href="../../doc/vigra/group__GeometricTransformations.html#g06ddb213ebcfcd09923b36aff144e954">rotateImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray rotateImageSimple(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,enum vigra::RotationDirection=vigra.sampling.RotationDirection.CLOCKWISE [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<hr class="docutils" />
<p>Spline image views implement an interpolated view for an image which can be accessed
at real-valued coordinates (in contrast to the plain image, which can only be
accessed at integer coordinates). Module vigra.sampling defines:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">SplineImageView0</span>
<span class="n">SplineImageView1</span>
<span class="n">SplineImageView2</span>
<span class="n">SplineImageView3</span>
<span class="n">SplineImageView4</span>
<span class="n">SplineImageView5</span>
</pre></div>
</div>
<p>The number denotes the spline interpolation order of the respective classes.
Below, we describe SplineImageView3 in detail, but the other classes work
analogously. See <a class="reference external" href="../../doc/vigra/classvigra_1_1SplineImageView.html">SplineImageView</a> in the C++ documentation for more detailed information.</p>
<dl class="class">
<dt id="vigra.sampling.SplineImageView3">
<em class="property">class </em><tt class="descclassname">vigra.sampling.</tt><tt class="descname">SplineImageView3</tt><a class="headerlink" href="#vigra.sampling.SplineImageView3" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>__init__( (object)arg1, (object)arg2) -&gt; object :</dt>
<dd><p class="first">Construct a SplineImageView for the given image:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">SplineImageView</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="n">skipPrefilter</span> <span class="o">=</span> <span class="bp">False</span><span class="p">)</span>
</pre></div>
</div>
<p>Currently, &#8216;image&#8217; can have dtype numpy.uint8, numpy.int32, and numpy.float32. If &#8216;skipPrefilter&#8217; is True, image values are directly used as spline coefficients, so that the view performs approximation rather than interploation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void * __init__(class boost::python::api::object,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;)</dd>
</dl>
</dd>
</dl>
<p>__init__( (object)arg1, (object)arg2) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void * __init__(class boost::python::api::object,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;long&gt;,struct vigra::StridedArrayTag&gt;)</dd>
</dl>
</blockquote>
<p>__init__( (object)arg1, (object)arg2) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void * __init__(class boost::python::api::object,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;)</dd>
</dl>
</blockquote>
<p>__init__( (object)arg1, (object)arg2, (bool)arg3) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void * __init__(class boost::python::api::object,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,bool)</dd>
</dl>
</blockquote>
<p>__init__( (object)arg1, (object)arg2, (bool)arg3) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void * __init__(class boost::python::api::object,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;long&gt;,struct vigra::StridedArrayTag&gt;,bool)</dd>
</dl>
</blockquote>
<p>__init__( (object)arg1, (object)arg2, (bool)arg3) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>void * __init__(class boost::python::api::object,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,bool)</dd>
</dl>
</blockquote>
<dl class="method">
<dt id="vigra.sampling.SplineImageView3.coefficientImage">
<tt class="descname">coefficientImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.coefficientImage" title="Permalink to this definition">¶</a></dt>
<dd><p>coefficientImage( (SplineImageView3)arg1) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; coefficientImage(class vigra::SplineImageView&lt;3,float&gt;)</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dx">
<tt class="descname">dx</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dx" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dx( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return first derivative in x direction at a real-valued coordinate.</p>
<p>SplineImageView.dx(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float dx(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dx3">
<tt class="descname">dx3</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dx3" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dx3( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return third derivative in x direction at a real-valued coordinate.</p>
<p>SplineImageView.dx3(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float dx3(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dx3Image">
<tt class="descname">dx3Image</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dx3Image" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dx3Image( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.dx3" class="reference internal" href="#vigra.sampling.SplineImageView3.dx3"><tt class="xref docutils literal"><span class="pre">dx3()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.dx3Image(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; dx3Image(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dxImage">
<tt class="descname">dxImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dxImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dxImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.dx" class="reference internal" href="#vigra.sampling.SplineImageView3.dx"><tt class="xref docutils literal"><span class="pre">dx()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.dxImage(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; dxImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dxx">
<tt class="descname">dxx</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dxx" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dxx( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return second derivative in x direction at a real-valued coordinate.</p>
<p>SplineImageView.dxx(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float dxx(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dxxImage">
<tt class="descname">dxxImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dxxImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dxxImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.dxx" class="reference internal" href="#vigra.sampling.SplineImageView3.dxx"><tt class="xref docutils literal"><span class="pre">dxx()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.dxxImage(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; dxxImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dxxy">
<tt class="descname">dxxy</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dxxy" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dxxy( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return mixed third derivative at a real-valued coordinate.</p>
<p>SplineImageView.dxxy(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float dxxy(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dxxyImage">
<tt class="descname">dxxyImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dxxyImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dxxyImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.dxxy" class="reference internal" href="#vigra.sampling.SplineImageView3.dxxy"><tt class="xref docutils literal"><span class="pre">dxxy()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.dxxyImage(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; dxxyImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dxy">
<tt class="descname">dxy</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dxy" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dxy( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return mixed second derivative at a real-valued coordinate.</p>
<p>SplineImageView.dxy(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float dxy(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dxyImage">
<tt class="descname">dxyImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dxyImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dxyImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.dxy" class="reference internal" href="#vigra.sampling.SplineImageView3.dxy"><tt class="xref docutils literal"><span class="pre">dxy()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.dxyImage(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; dxyImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dxyy">
<tt class="descname">dxyy</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dxyy" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dxyy( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return mixed third derivative at a real-valued coordinate.</p>
<p>SplineImageView.dxyy(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float dxyy(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dxyyImage">
<tt class="descname">dxyyImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dxyyImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dxyyImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.dxyy" class="reference internal" href="#vigra.sampling.SplineImageView3.dxyy"><tt class="xref docutils literal"><span class="pre">dxyy()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.dxyyImage(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; dxyyImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dy">
<tt class="descname">dy</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dy" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dy( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return first derivative in y direction at a real-valued coordinate.</p>
<p>SplineImageView.dy(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float dy(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dy3">
<tt class="descname">dy3</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dy3" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dy3( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return third derivative in y direction at a real-valued coordinate.</p>
<p>SplineImageView.dy3(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float dy3(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dy3Image">
<tt class="descname">dy3Image</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dy3Image" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dy3Image( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.dy3" class="reference internal" href="#vigra.sampling.SplineImageView3.dy3"><tt class="xref docutils literal"><span class="pre">dy3()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.dy3Image(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; dy3Image(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dyImage">
<tt class="descname">dyImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dyImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dyImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.dy" class="reference internal" href="#vigra.sampling.SplineImageView3.dy"><tt class="xref docutils literal"><span class="pre">dy()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.dyImage(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; dyImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dyy">
<tt class="descname">dyy</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dyy" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dyy( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return second derivative in y direction at a real-valued coordinate.</p>
<p>SplineImageView.dyy(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float dyy(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.dyyImage">
<tt class="descname">dyyImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.dyyImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>dyyImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.dyy" class="reference internal" href="#vigra.sampling.SplineImageView3.dyy"><tt class="xref docutils literal"><span class="pre">dyy()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.dyyImage(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; dyyImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.facetCoefficients">
<tt class="descname">facetCoefficients</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.facetCoefficients" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>facetCoefficients( (SplineImageView3)arg1, (float)arg2, (float)arg3) -&gt; object :</dt>
<dd><p class="first">SplineImageView.facetCoefficients(x, y) -&gt; matrix</p>
<p>Return the facet coefficient matrix so that spline values can be computed
explicitly. The matrix has size (order+1)x(order+1), where order is 
the order of the spline. The matrix must be multiplied from left and right
with the powers of the local facet x- and y-coordinates respectively
(note that local facet coordinates are in the range [0,1] for odd order
splines and [-0.5, 0.5] for even order splines).</p>
<p>Usage for odd spline order:</p>
<blockquote>
s = SplineImageView3(image)
c = s.coefficients(10.1, 10.7)
x = matrix([1, 0.1, 0.1**2, 0.1**3])
y = matrix([1, 0.7, 0.7**2, 0.7**3])
assert abs(x * c * y.T - s[10.1, 10.7]) &lt; smallNumber</blockquote>
<p>Usage for even spline order:</p>
<blockquote>
s = SplineImageView2(image)
c = s.coefficients(10.1, 10.7)
x = matrix([1, 0.1, 0.1**2])
y = matrix([1, -0.3, (-0.3)**2])
assert abs(x * c * y.T - s[10.1, 10.7]) &lt; smallNumber</blockquote>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>struct _object * facetCoefficients(class vigra::SplineImageView&lt;3,float&gt;,double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.g2">
<tt class="descname">g2</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.g2" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>g2( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return gradient squared magnitude at a real-valued coordinate.</p>
<p>SplineImageView.g2(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float g2(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.g2Image">
<tt class="descname">g2Image</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.g2Image" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>g2Image( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.g2" class="reference internal" href="#vigra.sampling.SplineImageView3.g2"><tt class="xref docutils literal"><span class="pre">g2()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.g2Image(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; g2Image(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.g2x">
<tt class="descname">g2x</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.g2x" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>g2x( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return first derivative in x direction of the gradient squared magnitude at a real-valued coordinate.</p>
<p>SplineImageView.g2x(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float g2x(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.g2xImage">
<tt class="descname">g2xImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.g2xImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>g2xImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.g2x" class="reference internal" href="#vigra.sampling.SplineImageView3.g2x"><tt class="xref docutils literal"><span class="pre">g2x()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.g2xImage(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; g2xImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.g2y">
<tt class="descname">g2y</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.g2y" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>g2y( (SplineImageView3)arg1, (float)x, (float)y) -&gt; float :</dt>
<dd><p class="first">Return first derivative in y direction of the gradient squared magnitude at a real-valued coordinate.</p>
<p>SplineImageView.g2y(x, y) -&gt; value</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>float g2y(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.g2yImage">
<tt class="descname">g2yImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.g2yImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>g2yImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0]]) -&gt; object :</dt>
<dd><p class="first">Like <a title="vigra.sampling.SplineImageView3.g2y" class="reference internal" href="#vigra.sampling.SplineImageView3.g2y"><tt class="xref docutils literal"><span class="pre">g2y()</span></tt></a>, but returns an entire image with the given sampling factors. For example,</p>
<p>SplineImageView.g2yImage(2.0, 2.0) -&gt; image</p>
<p>creates an derivative image with two-fold oversampling in both directions.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; g2yImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.height">
<tt class="descname">height</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.height" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>height( (SplineImageView3)arg1) -&gt; int :</dt>
<dd><p class="first">The height of the underlying image.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>unsigned int height(class vigra::SplineImageView&lt;3,float&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.interpolatedImage">
<tt class="descname">interpolatedImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.interpolatedImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>interpolatedImage( (SplineImageView3)arg1 [, (float)xfactor=2.0 [, (float)yfactor=2.0 [, (int)xorder=0 [, (int)yorder=0]]]]) -&gt; object :</dt>
<dd><p class="first">Return an interpolated image or derivative image with the given sampling factors and derivative orders. For example, we get a two-fold oversampled image with the x-derivatives in each pixel by:</p>
<p>SplineImageView.interpolatedImage(2.0, 2.0, 1, 0) -&gt; image</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; interpolatedImage(class vigra::SplineImageView&lt;3,float&gt; [,double=2.0 [,double=2.0 [,unsigned int=0 [,unsigned int=0]]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.isInside">
<tt class="descname">isInside</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.isInside" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>isInside( (SplineImageView3)arg1, (float)arg2, (float)arg3) -&gt; bool :</dt>
<dd><p class="first">Check if a coordinate is inside the underlying image.</p>
<p>SplineImageView.isInside(x, y) -&gt; bool</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>bool isInside(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.isValid">
<tt class="descname">isValid</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.isValid" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>isValid( (SplineImageView3)arg1, (float)arg2, (float)arg3) -&gt; bool :</dt>
<dd><p class="first">Check if a coordinate is within the valid range of the SplineImageView.</p>
<p>SplineImageView.isValid(x, y) -&gt; bool</p>
<p>Thanks to reflective boundary conditions, the valid range is three times as big as the size of the underlying image.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>bool isValid(class vigra::SplineImageView&lt;3,float&gt; {lvalue},double,double)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.shape">
<tt class="descname">shape</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.shape" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>shape( (SplineImageView3)arg1) -&gt; object :</dt>
<dd><p class="first">The shape of the underlying image.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::TinyVector&lt;unsigned int,2&gt; shape(class vigra::SplineImageView&lt;3,float&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.size">
<tt class="descname">size</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.size" title="Permalink to this definition">¶</a></dt>
<dd><p>size( (SplineImageView3)arg1) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::TinyVector&lt;unsigned int,2&gt; size(class vigra::SplineImageView&lt;3,float&gt; {lvalue})</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="method">
<dt id="vigra.sampling.SplineImageView3.width">
<tt class="descname">width</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.sampling.SplineImageView3.width" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>width( (SplineImageView3)arg1) -&gt; int :</dt>
<dd><p class="first">The width of the underlying image.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>unsigned int width(class vigra::SplineImageView&lt;3,float&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

</dd></dl>

</div>
<div class="section" id="module-vigra.fourier">
<h2><a class="toc-backref" href="#id180">Fourier Transforms</a><a class="headerlink" href="#module-vigra.fourier" title="Permalink to this headline">¶</a></h2>
<p>The module vigra.fourier contains functions for Fourier transforms, Cosine/Sine
transforms, and Fourier-domain filters.</p>
<dl class="function">
<dt id="vigra.fourier.fourierTransform">
<tt class="descclassname">vigra.fourier.</tt><tt class="descname">fourierTransform</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.fourier.fourierTransform" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>fourierTransform( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Perform 2-dimensional or 3-dimensional Fourier transformation of a scalar or complex array.If the input array has multiple channels, each channel is transformed separately.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray fourierTransform(class vigra::NumpyAnyArray [,class vigra::NumpyAnyArray=None])</dd>
</dl>
</dd>
</dl>
<p>fourierTransform( (object)image [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray fourierTransform(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;class vigra::FFTWComplex&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;class vigra::FFTWComplex&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
<p>fourierTransform( (object)image [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray fourierTransform(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;class vigra::FFTWComplex&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;class vigra::FFTWComplex&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.fourier.fourierTransformInverse">
<tt class="descclassname">vigra.fourier.</tt><tt class="descname">fourierTransformInverse</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.fourier.fourierTransformInverse" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>fourierTransformInverse( (object)image [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Perform 2-dimensional or 3-dimensional inverse Fourier transformation of a complex arrays.If the input array has multiple channels, each channel is transformed separately.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray fourierTransformInverse(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;class vigra::FFTWComplex&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;class vigra::FFTWComplex&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
<p>fourierTransformInverse( (object)image [, (object)out=None]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray fourierTransformInverse(class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;class vigra::FFTWComplex&gt;,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;4,struct vigra::Multiband&lt;class vigra::FFTWComplex&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</blockquote>
</dd></dl>

</div>
<div class="section" id="module-vigra.analysis">
<h2><a class="toc-backref" href="#id181">Image Analysis</a><a class="headerlink" href="#module-vigra.analysis" title="Permalink to this headline">¶</a></h2>
<p>The module vigra.analysis contains segmentation algorithms (e.g. watershed), edge and
corner detection, localization of maxima and minima etc.</p>
<dl class="class">
<dt id="vigra.analysis.Edgel">
<em class="property">class </em><tt class="descclassname">vigra.analysis.</tt><tt class="descname">Edgel</tt><a class="headerlink" href="#vigra.analysis.Edgel" title="Permalink to this definition">¶</a></dt>
<dd><p>Represent an Edgel at a particular subpixel position (x, y), having given &#8216;strength&#8217; and &#8216;orientation&#8217;.</p>
<p>For details, see <a class="reference external" href="../../doc/vigra/classvigra_1_1Edgel.html">Edgel</a> in the vigra C++ documentation.</p>
<dl class="docutils">
<dt>__init__( (object)arg1) -&gt; None :</dt>
<dd><p class="first">Standard constructor:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">Edgel</span><span class="p">()</span>
</pre></div>
</div>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void __init__(struct _object <a href="#id120"><span class="problematic" id="id121">*</span></a>)</dd>
</dl>
</dd>
<dt>__init__( (object)arg1, (float)x, (float)y, (float)strength, (float)orientation) -&gt; None :</dt>
<dd><p class="first">Constructor:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">Edgel</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">strength</span><span class="p">,</span> <span class="n">orientation</span><span class="p">)</span>
</pre></div>
</div>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void __init__(struct _object <a href="#id122"><span class="problematic" id="id123">*</span></a>,float,float,float,float)</dd>
</dl>
</dd>
</dl>
<dl class="attribute">
<dt id="vigra.analysis.Edgel.orientation">
<tt class="descname">orientation</tt><a class="headerlink" href="#vigra.analysis.Edgel.orientation" title="Permalink to this definition">¶</a></dt>
<dd>The edgel&#8217;s orientation.</dd></dl>

<dl class="attribute">
<dt id="vigra.analysis.Edgel.strength">
<tt class="descname">strength</tt><a class="headerlink" href="#vigra.analysis.Edgel.strength" title="Permalink to this definition">¶</a></dt>
<dd>The edgel&#8217;s strength.</dd></dl>

<dl class="attribute">
<dt id="vigra.analysis.Edgel.x">
<tt class="descname">x</tt><a class="headerlink" href="#vigra.analysis.Edgel.x" title="Permalink to this definition">¶</a></dt>
<dd>The edgel&#8217;s x position.</dd></dl>

<dl class="attribute">
<dt id="vigra.analysis.Edgel.y">
<tt class="descname">y</tt><a class="headerlink" href="#vigra.analysis.Edgel.y" title="Permalink to this definition">¶</a></dt>
<dd>The edgel&#8217;s y position.</dd></dl>

</dd></dl>

<dl class="function">
<dt id="vigra.analysis.beautifyCrackEdgeImage">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">beautifyCrackEdgeImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.beautifyCrackEdgeImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>beautifyCrackEdgeImage( (object)image, (int)edgeMarker, (int)backgroundMarker [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Beautify crack edge image for visualization.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__EdgeDetection.html#gd23b10d3d105e3a9e394e4542a1baa8b">beautifyCrackEdgeImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray beautifyCrackEdgeImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,unsigned char,unsigned char [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.cannyEdgeImage">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">cannyEdgeImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.cannyEdgeImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>cannyEdgeImage( (object)image, (float)scale, (float)threshold, (int)edgeMarker [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Detect and mark edges in an edge image using Canny&#8217;s algorithm.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__EdgeDetection.html#g587ce18f5e12bfa76e39696a93560a63">cannyEdgeImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray cannyEdgeImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double,unsigned char [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.cannyEdgeImageWithThinning">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">cannyEdgeImageWithThinning</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.cannyEdgeImageWithThinning" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>cannyEdgeImageWithThinning( (object)image, (float)scale, (float)threshold, (int)edgeMarker [, (bool)addBorder=True [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Detect and mark edges in an edge image using Canny&#8217;s algorithm.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__EdgeDetection.html#gdb574fc684ae8e15629ca77b0c961f21">cannyEdgeImageWithThinning</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray cannyEdgeImageWithThinning(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double,unsigned char [,bool=True [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.cannyEdgelList">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">cannyEdgelList</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.cannyEdgelList" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>cannyEdgelList( (object)gradient, (float)threshold) -&gt; list :</dt>
<dd><p class="first">Return a list of <a title="vigra.analysis.Edgel" class="reference internal" href="#vigra.analysis.Edgel"><tt class="xref docutils literal"><span class="pre">Edgel</span></tt></a> objects whose strength is at least &#8216;threshold&#8217;.</p>
<p>The function comes in two forms:</p>
<div class="highlight-python"><pre>cannyEdgelList(gradient, threshold) -&gt; list
cannyEdgelList(image, scale, threshold) -&gt; list</pre>
</div>
<p>The first form expects a gradient image (i.e. with two channels) to compute edgels, whereas the second form expects a scalar image and computes the gradient internally at &#8216;scale&#8217;.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__EdgeDetection.html#g07d8d68b29292a80213bfcd00cff2410">cannyEdgelList</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::list cannyEdgelList(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,2&gt;,struct vigra::StridedArrayTag&gt;,double)</dd>
</dl>
</dd>
</dl>
<p>cannyEdgelList( (object)image, (float)scale, (float)threshold) -&gt; list :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::list cannyEdgelList(class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;,double,double)</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.cannyEdgelList3x3">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">cannyEdgelList3x3</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.cannyEdgelList3x3" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>cannyEdgelList3x3( (object)gradient, (float)threshold) -&gt; list :</dt>
<dd><p class="first">Return a list of <a title="vigra.analysis.Edgel" class="reference internal" href="#vigra.analysis.Edgel"><tt class="xref docutils literal"><span class="pre">Edgel</span></tt></a> objects whose strength is at least &#8216;threshold&#8217;.</p>
<p>The function comes in two forms:</p>
<div class="highlight-python"><pre>cannyEdgelList3x3(gradient, threshold) -&gt; list
cannyEdgelList3x3(image, scale, threshold) -&gt; list</pre>
</div>
<p>The first form expects a gradient image (i.e. with two channels) to compute edgels, whereas the second form expects a scalar image and computes the gradient internally at &#8216;scale&#8217;. The results are slightly better than those of <a title="vigra.analysis.cannyEdgelList" class="reference internal" href="#vigra.analysis.cannyEdgelList"><tt class="xref docutils literal"><span class="pre">cannyEdgelList()</span></tt></a>.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__EdgeDetection.html#g36f25b87755f840fed095aa28c56f030">cannyEdgelList3x3</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::list cannyEdgelList3x3(class vigra::NumpyArray&lt;2,class vigra::TinyVector&lt;float,2&gt;,struct vigra::StridedArrayTag&gt;,double)</dd>
</dl>
</dd>
</dl>
<p>cannyEdgelList3x3( (object)image, (float)scale, (float)threshold) -&gt; list :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::list cannyEdgelList3x3(class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;,double,double)</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.closeGapsInCrackEdgeImage">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">closeGapsInCrackEdgeImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.closeGapsInCrackEdgeImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>closeGapsInCrackEdgeImage( (object)image, (int)edgeMarker [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Close one-pixel wide gaps in a cell grid edge image.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__EdgeDetection.html#gf3413437b6a66fbd9cb2c8327d113465">closeGapsInCrackEdgeImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray closeGapsInCrackEdgeImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,unsigned char [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.cornernessBeaudet">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">cornernessBeaudet</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.cornernessBeaudet" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>cornernessBeaudet( (object)image, (float)scale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Find corners in a scalar 2D image using the method of Beaudet at the given &#8216;scale&#8217;.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__CornerDetection.html#gc4ba1688df07b4108f2d58b9def9de6c">beaudetCornerDetector</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray cornernessBeaudet(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.cornernessBoundaryTensor">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">cornernessBoundaryTensor</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.cornernessBoundaryTensor" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>cornernessBoundaryTensor( (object)image, (float)scale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Find corners in a scalar 2D image using the boundary tensor at the given &#8216;scale&#8217;.</p>
<p>Specifically, the cornerness is defined as twice the small eigenvalue of the boundary tensor.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__TensorImaging.html#g3f60d75d3f938c3805544c28e5aa0053">boundaryTensor</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray cornernessBoundaryTensor(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.cornernessFoerstner">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">cornernessFoerstner</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.cornernessFoerstner" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>cornernessFoerstner( (object)image, (float)scale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Find corners in a scalar 2D image using the method of Foerstner at the given &#8216;scale&#8217;.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__CornerDetection.html#g8ab2b794a398f932faaf1dc1ea9fc56b">foerstnerCornerDetector</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray cornernessFoerstner(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.cornernessHarris">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">cornernessHarris</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.cornernessHarris" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>cornernessHarris( (object)image, (float)scale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Find corners in a scalar 2D image using the method of Harris at the given &#8216;scale&#8217;.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__CornerDetection.html#g9b5514a5a65bf24c112616b7ce2496c9">cornerResponseFunction</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray cornernessHarris(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.cornernessRohr">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">cornernessRohr</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.cornernessRohr" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>cornernessRohr( (object)image, (float)scale [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Find corners in a scalar 2D image using the method of Rohr at the given &#8216;scale&#8217;.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__CornerDetection.html#g8067aa7bc38c093984e75b2d4ea1bf50">rohrCornerDetector</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray cornernessRohr(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.extendedLocalMaxima">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">extendedLocalMaxima</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.extendedLocalMaxima" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>extendedLocalMaxima( (object)image [, (float)marker=1.0 [, (int)neighborhood=8 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Find local maxima and maximal plateaus in an image and mark them with the given &#8216;marker&#8217;. Parameter &#8216;neighborhood&#8217; specifies the pixel neighborhood to be used and can be 4 or 8 (default).</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__LocalMinMax.html#g0a7f570a1fa1a6594d61612f13a42673">localMinima</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray extendedLocalMaxima(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,float=1.0 [,int=8 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.extendedLocalMinima">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">extendedLocalMinima</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.extendedLocalMinima" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>extendedLocalMinima( (object)image [, (float)marker=1.0 [, (int)neighborhood=8 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Find local minima and minimal plateaus in an image and mark them with the given &#8216;marker&#8217;. Parameter &#8216;neighborhood&#8217; specifies the pixel neighborhood to be used and can be 4 or 8 (default).</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__LocalMinMax.html#g2104a22ababf2e10b82f6ae30154f4f7">extendedLocalMinima</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray extendedLocalMinima(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,float=1.0 [,int=8 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.labelImage">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">labelImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.labelImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>labelImage( (object)image [, (int)neighborhood=4 [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Find the connected components of a segmented image. Parameter &#8216;neighborhood&#8217; specifies the pixel neighborhood to be used and can be 4 (default) or 8.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__Labeling.html#g28c7e612b6e8f2dfd1a544ba14987029">labelImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray labelImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt; [,int=4 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
<p>labelImage( (object)image [, (int)neighborhood=4 [, (object)out=None]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray labelImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,int=4 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.labelImageWithBackground">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">labelImageWithBackground</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.labelImageWithBackground" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>labelImageWithBackground( (object)image [, (int)neighborhood=4 [, (int)background_value=0 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Find the connected components of a segmented image, excluding the background from labeling, where the background is the set of all pixels with the given &#8216;background_value&#8217;. Parameter &#8216;neighborhood&#8217; specifies the pixel neighborhood to be used and can be 4 (default) or 8.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__Labeling.html#g4e60cb9394ef08fb588a068c3790b3bd">labelImageWithBackground</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray labelImageWithBackground(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt; [,int=4 [,unsigned char=0 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
<p>labelImageWithBackground( (object)image [, (int)neighborhood=4 [, (float)background_value=0 [, (object)out=None]]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray labelImageWithBackground(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,int=4 [,float=0 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.labelVolume">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">labelVolume</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.labelVolume" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>labelVolume( (object)volume [, (int)neighborhood=6 [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Find the connected components of a segmented volume. Parameter &#8216;neighborhood&#8217; specifies the pixel neighborhood to be used and can be 6 (default) or 26.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__Labeling.html#g84696c6009abe81315e52585a0b5cc2b">labelVolume</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray labelVolume(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt; [,int=6 [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
<p>labelVolume( (object)volume [, (int)neighborhood=6 [, (object)out=None]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray labelVolume(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,int=6 [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.labelVolumeWithBackground">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">labelVolumeWithBackground</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.labelVolumeWithBackground" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>labelVolumeWithBackground( (object)volume [, (int)neighborhood=6 [, (int)background_value=0 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Find the connected components of a segmented volume, excluding the background from labeling, where the background is the set of all pixels with the given &#8216;background_value&#8217;. Parameter &#8216;neighborhood&#8217; specifies the pixel neighborhood to be used and can be 6 (default) or 26.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__Labeling.html#g2e8fdf4d58f1255e5cc49feaec8d5acf">labelVolumeWithBackground</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray labelVolumeWithBackground(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt; [,int=6 [,unsigned char=0 [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
<p>labelVolumeWithBackground( (object)volume [, (int)neighborhood=6 [, (float)background_value=0 [, (object)out=None]]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray labelVolumeWithBackground(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,int=6 [,float=0 [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.localMaxima">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">localMaxima</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.localMaxima" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>localMaxima( (object)image [, (float)marker=1.0 [, (int)neighborhood=8 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Find local maxima in an image and mark them with the given &#8216;marker&#8217;. Parameter &#8216;neighborhood&#8217; specifies the pixel neighborhood to be used and can be 4 or 8 (default).</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__LocalMinMax.html#g2e848443425d0062cea70f7b7332434e">localMaxima</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray localMaxima(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,float=1.0 [,int=8 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.localMinima">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">localMinima</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.localMinima" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>localMinima( (object)image [, (float)marker=1.0 [, (int)neighborhood=8 [, (object)out=None]]]) -&gt; object :</dt>
<dd><p class="first">Find local minima in an image and mark them with the given &#8216;marker&#8217;. Parameter &#8216;neighborhood&#8217; specifies the pixel neighborhood to be used and can be 4 or 8 (default).</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__LocalMinMax.html#g0a7f570a1fa1a6594d61612f13a42673">localMinima</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray localMinima(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,float=1.0 [,int=8 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.regionImageToCrackEdgeImage">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">regionImageToCrackEdgeImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.regionImageToCrackEdgeImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>regionImageToCrackEdgeImage( (object)image [, (int)edgeLabel=0 [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Transform a labeled image into a crack edge image.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__Labeling.html#g28be01b8886f978964168985c1d3df74">regionImageToCrackEdgeImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray regionImageToCrackEdgeImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt; [,unsigned long=0 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
<p>regionImageToCrackEdgeImage( (object)image [, (long)edgeLabel=0 [, (object)out=None]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray regionImageToCrackEdgeImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned __int64&gt;,struct vigra::StridedArrayTag&gt; [,unsigned __int64=0 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned __int64&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.regionImageToEdgeImage">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">regionImageToEdgeImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.regionImageToEdgeImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>regionImageToEdgeImage( (object)image [, (int)edgeLabel=0 [, (object)out=None]]) -&gt; object :</dt>
<dd><p class="first">Transform a labeled image into an edge image.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__Labeling.html#gae92b7ba1a66dca507dcf95b82b289e3">regionImageToEdgeImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray regionImageToEdgeImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt; [,unsigned long=0 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</dd>
</dl>
<p>regionImageToEdgeImage( (object)image [, (long)edgeLabel=0 [, (object)out=None]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray regionImageToEdgeImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned __int64&gt;,struct vigra::StridedArrayTag&gt; [,unsigned __int64=0 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned __int64&gt;,struct vigra::StridedArrayTag&gt;=None]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.removeShortEdges">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">removeShortEdges</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.removeShortEdges" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>removeShortEdges( (object)image, (int)minEdgeLength, (int)nonEdgeMarker [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Remove short edges from an edge image.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__EdgeDetection.html#g78ffe78118c0d65bf33c0ed2a4db3983">removeShortEdges</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray removeShortEdges(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;,int,unsigned char [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.shenCastanCrackEdgeImage">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">shenCastanCrackEdgeImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.shenCastanCrackEdgeImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>shenCastanCrackEdgeImage( (object)image, (float)scale, (float)threshold, (int)edgeMarker [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Detect and mark edges in a crack edge image using the Shen/Castan zero-crossing detector.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__EdgeDetection.html#g03891ba21dd1b7c5d8c3337423dcf34b">differenceOfExponentialCrackEdgeImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray shenCastanCrackEdgeImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double,unsigned char [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.shenCastanEdgeImage">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">shenCastanEdgeImage</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.shenCastanEdgeImage" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>shenCastanEdgeImage( (object)image, (float)scale, (float)threshold, (int)edgeMarker [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Detect and mark edges in an edge image using the Shen/Castan zero-crossing detector.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__EdgeDetection.html#ga5d344b259ecef092a63d153b1e6b24c">differenceOfExponentialEdgeImage</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray shenCastanEdgeImage(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double,unsigned char [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.watersheds">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">watersheds</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.analysis.watersheds" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>watersheds( (object)image [, (int)neighborhood=4 [, (object)seeds=None [, (str)method=&#8217;RegionGrowing&#8217; [, (SRGType)terminate=vigra.analysis.SRGType.CompleteGrow [, (int)max_cost=0.0 [, (object)out=None]]]]]]) -&gt; tuple :</dt>
<dd><p class="first">Compute the watersheds of a 2D or 3D image.</p>
<blockquote>
<dl class="docutils">
<dt>watersheds(image, neighborhood=4, seeds = None, methods = &#8216;RegionGrowing&#8217;, </dt>
<dd>terminate=CompleteGrow, threshold=0, out = None) -&gt; (labelimage, max_ragion_label)</dd>
</dl>
</blockquote>
<p>Parameters:</p>
<blockquote>
<dl class="docutils">
<dt>image:</dt>
<dd>the image or volume containing the boundary indicator values     (high values = high edgeness)</dd>
<dt>neighborhood:</dt>
<dd><p class="first">the pixel neighborhood to be used. Feasible values depend on the     dimension and method:</p>
<blockquote class="last">
<dl class="docutils">
<dt>2-dimensional data:</dt>
<dd>4 (default) or 8.</dd>
<dt>3-dimensional data:</dt>
<dd>6 (default) or 26</dd>
</dl>
</blockquote>
</dd>
<dt>seeds:</dt>
<dd>a label image specifying region seeds, only supported by method &#8216;RegionGrowing&#8217;</dd>
<dt>method:</dt>
<dd><p class="first">the algorithm to be used for watershed computation. Possible values:</p>
<blockquote class="last">
<dl class="docutils">
<dt>&#8216;RegionGrowing&#8217;:</dt>
<dd>(default) use <a class="reference external" href="../../doc/vigra/group__SeededRegionGrowing.html#gd236be19d1ef7ff0ee2af08182f76dc0">seededRegionGrowing</a> or <a class="reference external" href="../../doc/vigra/group__SeededRegionGrowing.html#gd07f44d3bf8492d70058b3e8cea541a3">seededRegionGrowing3D</a> respectively</dd>
<dt>&#8216;UnionFind:</dt>
<dd>use <a class="reference external" href="../../doc/vigra/group__SeededRegionGrowing.html#g3b5e1e5125417d96ec2ce5c082403998">watersheds</a> or <a class="reference external" href="../../doc/vigra/group__SeededRegionGrowing.html#gfb49a165a60ea64cd5f89d23c48883ee">watersheds3D</a> respectively</dd>
</dl>
</blockquote>
</dd>
<dt>terminate:</dt>
<dd><p class="first">when to stop growing. Possible values:</p>
<blockquote class="last">
<dl class="docutils">
<dt>CompleteGrow:</dt>
<dd>(default) grow until all pixels are assigned to a region</dd>
<dt>KeepCountours:</dt>
<dd>keep a 1-pixel wide contour between all regions, only supported         by method &#8216;RegionGrowing&#8217;</dd>
<dt>StopAtThreshold:</dt>
<dd>stop when the boundary indicator values exceed the threshold given by         parameter &#8216;max_cost&#8217;, only supported by method &#8216;RegionGrowing&#8217;</dd>
<dt>KeepCountours | StopAtThreshold:</dt>
<dd>keep 1-pixel wide contour and stop at given &#8216;max_cost&#8217;, only         supported by method &#8216;RegionGrowing&#8217;</dd>
</dl>
</blockquote>
</dd>
<dt>max_cost:</dt>
<dd>terminate growing when boundary indicator exceeds this value (ignored when     &#8216;terminate&#8217; is not StopAtThreshold or method is not &#8216;RegionGrowing&#8217;)</dd>
<dt>out:</dt>
<dd>the label image (with dtype=numpy.uint32) to be filled by the algorithm.     It will be allocated by the watershed function if not provided)</dd>
</dl>
</blockquote>
<p>The function returns a Python tuple (labelImage, maxRegionLabel)</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::tuple watersheds(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt; [,int=4 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None [,class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt;=&#8217;RegionGrowing&#8217; [,enum vigra::SRGType=vigra.analysis.SRGType.CompleteGrow [,unsigned char=0.0 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]])</dd>
</dl>
</dd>
</dl>
<p>watersheds( (object)image [, (int)neighborhood=4 [, (object)seeds=None [, (str)method=&#8217;RegionGrowing&#8217; [, (SRGType)terminate=vigra.analysis.SRGType.CompleteGrow [, (float)max_cost=0.0 [, (object)out=None]]]]]]) -&gt; tuple :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::tuple watersheds(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,int=4 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None [,class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt;=&#8217;RegionGrowing&#8217; [,enum vigra::SRGType=vigra.analysis.SRGType.CompleteGrow [,float=0.0 [,class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]])</dd>
</dl>
</blockquote>
<p>watersheds( (object)image [, (int)neighborhood=6 [, (object)seeds=None [, (str)method=&#8217;RegionGrowing&#8217; [, (SRGType)terminate=vigra.analysis.SRGType.CompleteGrow [, (int)max_cost=0.0 [, (object)out=None]]]]]]) -&gt; tuple :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::tuple watersheds(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned char&gt;,struct vigra::StridedArrayTag&gt; [,int=6 [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None [,class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt;=&#8217;RegionGrowing&#8217; [,enum vigra::SRGType=vigra.analysis.SRGType.CompleteGrow [,unsigned char=0.0 [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]])</dd>
</dl>
</blockquote>
<p>watersheds( (object)image [, (int)neighborhood=6 [, (object)seeds=None [, (str)method=&#8217;RegionGrowing&#8217; [, (SRGType)terminate=vigra.analysis.SRGType.CompleteGrow [, (float)max_cost=0.0 [, (object)out=None]]]]]]) -&gt; tuple :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::tuple watersheds(class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,int=6 [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None [,class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt;=&#8217;RegionGrowing&#8217; [,enum vigra::SRGType=vigra.analysis.SRGType.CompleteGrow [,float=0.0 [,class vigra::NumpyArray&lt;3,struct vigra::Singleband&lt;unsigned long&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.analysis.watershedsUnionFind">
<tt class="descclassname">vigra.analysis.</tt><tt class="descname">watershedsUnionFind</tt><big>(</big><em>image</em>, <em>neighborhood=None</em>, <em>out=None</em><big>)</big><a class="headerlink" href="#vigra.analysis.watershedsUnionFind" title="Permalink to this definition">¶</a></dt>
<dd><p>Compute watersheds of an image using the union find algorithm.
If &#8216;neighborhood&#8217; is &#8216;None&#8217;, it defaults to 8-neighborhood for 2D inputs
and 6-neighborhood for 3D inputs.</p>
<p>Calls <a title="vigra.analysis.watersheds" class="reference internal" href="#vigra.analysis.watersheds"><tt class="xref docutils literal"><span class="pre">watersheds()</span></tt></a> with parameters:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">watersheds</span><span class="p">(</span><span class="n">image</span><span class="p">,</span> <span class="n">neighborhood</span><span class="o">=</span><span class="n">neighborhood</span><span class="p">,</span> <span class="n">method</span><span class="o">=</span><span class="s">&#39;UnionFind&#39;</span><span class="p">,</span> <span class="n">out</span><span class="o">=</span><span class="n">out</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>

</div>
<div class="section" id="module-vigra.learning">
<h2><a class="toc-backref" href="#id182">Machine Learning</a><a class="headerlink" href="#module-vigra.learning" title="Permalink to this headline">¶</a></h2>
<p>The module vigra.learning will eventually provide a wide range of machine learning
tools. Right now, it only contains an implementation of the random forest classifier.</p>
<dl class="class">
<dt id="vigra.learning.RandomForest">
<em class="property">class </em><tt class="descclassname">vigra.learning.</tt><tt class="descname">RandomForest</tt><a class="headerlink" href="#vigra.learning.RandomForest" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>__init__( (object)arg1 [, (int)treeCount=255 [, (int)mtry=vigra.learning.RF_MTRY_SWITCH.RF_MTRY_SQRT [, (int)min_split_node_size=1 [, (int)training_set_size=0 [, (float)training_set_proportions=1.0 [, (bool)sample_with_replacement=True [, (bool)sample_classes_individually=False [, (bool)prepare_online_learning=False]]]]]]]]) -&gt; object :</dt>
<dd><p class="first">Constructor:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">RandomForest</span><span class="p">(</span><span class="n">treeCount</span> <span class="o">=</span> <span class="mi">255</span><span class="p">,</span> <span class="n">mtry</span><span class="o">=</span><span class="n">RF_SQRT</span><span class="p">,</span> <span class="n">min_split_node_size</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span>
             <span class="n">training_set_size</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">training_set_proportions</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span>
             <span class="n">sample_with_replacement</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">sample_classes_individually</span><span class="o">=</span><span class="bp">False</span><span class="p">,</span>
             <span class="n">prepare_online_learning</span><span class="o">=</span><span class="bp">False</span><span class="p">)</span>
</pre></div>
</div>
<p>&#8216;treeCount&#8217; controls the number of trees that are created.</p>
<p>See <a class="reference external" href="../../doc/vigra/classvigra_1_1RandomForest.html">RandomForest</a> and <a class="reference external" href="../../doc/vigra/classvigra_1_1RandomForestOptions.html">RandomForestOptions</a> in the C++ documentation for the meaning of the other parameters.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void * __init__(class boost::python::api::object [,int=255 [,int=vigra.learning.RF_MTRY_SWITCH.RF_MTRY_SQRT [,int=1 [,int=0 [,float=1.0 [,bool=True [,bool=False [,bool=False]]]]]]]])</dd>
</dl>
</dd>
<dt>__init__( (object)arg1, (str)filename [, (str)pathInFile=&#8217;&#8216;]) -&gt; object :</dt>
<dd><p class="first">Load from HDF5 file:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">RandomForest</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="n">pathInFile</span><span class="p">)</span>
</pre></div>
</div>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void * __init__(class boost::python::api::object,class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt; [,class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt;=&#8217;&#8216;])</dd>
</dl>
</dd>
</dl>
<dl class="method">
<dt id="vigra.learning.RandomForest.featureCount">
<tt class="descname">featureCount</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.featureCount" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>featureCount( (RandomForest)arg1) -&gt; int :</dt>
<dd><p class="first">Returns the number of features the RandomForest works with.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int featureCount(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForest.labelCount">
<tt class="descname">labelCount</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.labelCount" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>labelCount( (RandomForest)arg1) -&gt; int :</dt>
<dd><p class="first">Returns the number of labels, the RandomForest knows.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int labelCount(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForest.learnRF">
<tt class="descname">learnRF</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.learnRF" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>learnRF( (RandomForest)arg1, (object)trainData, (object)trainLabels) -&gt; float :</dt>
<dd><p class="first">Trains a random Forest using &#8216;trainData&#8217; and &#8216;trainLabels&#8217;.</p>
<p>and returns the OOB. See the vigra documentation for the meaning af the rest of the paremeters.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>double learnRF(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt; {lvalue},class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;,class vigra::NumpyArray&lt;2,unsigned int,struct vigra::StridedArrayTag&gt;)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForest.learnRFWithFeatureSelection">
<tt class="descname">learnRFWithFeatureSelection</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.learnRFWithFeatureSelection" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>learnRFWithFeatureSelection( (RandomForest)arg1, (object)trainData, (object)trainLabels) -&gt; tuple :</dt>
<dd><p class="first">Train a random Forest using &#8216;trainData&#8217; and &#8216;trainLabels&#8217;.</p>
<p>and returns the OOB and the Variable importanceSee the vigra documentation for the meaning af the rest of the paremeters.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class boost::python::tuple learnRFWithFeatureSelection(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt; {lvalue},class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;,class vigra::NumpyArray&lt;2,unsigned int,struct vigra::StridedArrayTag&gt;)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForest.onlineLearn">
<tt class="descname">onlineLearn</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.onlineLearn" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>onlineLearn( (RandomForest)arg1, (object)arg2, (object)trainData, (int)trainLabels, (bool)startIndex) -&gt; None :</dt>
<dd><p class="first">Learn online.</p>
<p>Works only if forest has been created with prepare_online_learning=true. Needs the old training data and the new appened, starting at startIndex.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void onlineLearn(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt; {lvalue},class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;,class vigra::NumpyArray&lt;2,unsigned int,struct vigra::StridedArrayTag&gt;,int,bool)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForest.predictLabels">
<tt class="descname">predictLabels</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.predictLabels" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>predictLabels( (RandomForest)arg1, (object)testData [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Predict labels on &#8216;testData&#8217;.</p>
<p>The output is an array containing a labels for every test samples.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray predictLabels(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt;,class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,unsigned int,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForest.predictProbabilities">
<tt class="descname">predictProbabilities</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.predictProbabilities" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>predictProbabilities( (RandomForest)arg1, (object)testData [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Predict probabilities for different classes on &#8216;testData&#8217;.</p>
<p>The output is an array containing a probability for every test sample and class.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray predictProbabilities(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt; {lvalue},class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
<dt>predictProbabilities( (RandomForest)arg1, (RF_OnlinePredictionSet)testData [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">The output is an array containing a probability for every test sample and class.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray predictProbabilities(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt; {lvalue},class vigra::OnlinePredictionSet&lt;float&gt; {lvalue} [,class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForest.reLearnTree">
<tt class="descname">reLearnTree</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.reLearnTree" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>reLearnTree( (RandomForest)arg1, (object)trainData, (object)trainLabels, (int)treeId) -&gt; None :</dt>
<dd><p class="first">Re-learn one tree of the forest using &#8216;trainData&#8217; and &#8216;trainLabels&#8217;.</p>
<p>and returns the OOB. This might be helpful in an online learning setup to improve the classifier.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void reLearnTree(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt; {lvalue},class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;,class vigra::NumpyArray&lt;2,unsigned int,struct vigra::StridedArrayTag&gt;,int)</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForest.treeCount">
<tt class="descname">treeCount</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.treeCount" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>treeCount( (RandomForest)arg1) -&gt; int :</dt>
<dd><p class="first">Returns the &#8216;treeCount&#8217;, that was set when constructing the RandomForest.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int treeCount(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForest.writeHDF5">
<tt class="descname">writeHDF5</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForest.writeHDF5" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>writeHDF5( (RandomForest)arg1, (str)filename [, (str)pathInFile=&#8217;&#8217; [, (bool)overwriteflag=False]]) -&gt; bool :</dt>
<dd><p class="first">Store the random forest in the given HDF5 file &#8216;filname&#8217; under the internal
path &#8216;pathInFile&#8217;. If a dataset already exists, &#8216;overwriteflag&#8217; determines
if the old data are overwritten.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>bool writeHDF5(class vigra::RandomForest&lt;unsigned int,struct vigra::ClassificationTag&gt;,class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt; [,class std::basic_string&lt;char,struct std::char_traits&lt;char&gt;,class std::allocator&lt;char&gt; &gt;=&#8217;&#8217; [,bool=False]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

</dd></dl>

<p>For more information, refer to <a class="reference external" href="../../doc/vigra/classvigra_1_1RandomForest.html">RandomForest</a> in the C++ documentation.</p>
<dl class="class">
<dt id="vigra.learning.RandomForestOld">
<em class="property">class </em><tt class="descclassname">vigra.learning.</tt><tt class="descname">RandomForestOld</tt><a class="headerlink" href="#vigra.learning.RandomForestOld" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>__init__( (object)arg1, (object)trainData, (object)trainLabels [, (int)treeCount=255 [, (int)mtry=0 [, (int)min_split_node_size=1 [, (int)training_set_size=0 [, (float)training_set_proportions=1.0 [, (bool)sample_with_replacement=True [, (bool)sample_classes_individually=False]]]]]]]) -&gt; object :</dt>
<dd><p class="first">Constructor:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">RandomForestOld</span><span class="p">(</span><span class="n">trainData</span><span class="p">,</span> <span class="n">trainLabels</span><span class="p">,</span>
                <span class="n">treeCount</span> <span class="o">=</span> <span class="mi">255</span><span class="p">,</span> <span class="n">mtry</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">min_split_node_size</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span>
                <span class="n">training_set_size</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">training_set_proportions</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span>
                <span class="n">sample_with_replacement</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">sample_classes_individually</span><span class="o">=</span><span class="bp">False</span><span class="p">,)</span>
</pre></div>
</div>
<p>Construct and train a RandomForest using &#8216;trainData&#8217; and &#8216;trainLabels&#8217;. &#8216;treeCount&#8217; controls the number of trees that are created.</p>
<p>See <a class="reference external" href="../../doc/vigra/classvigra_1_1RandomForest.html">RandomForest</a> and <a class="reference external" href="../../doc/vigra/classvigra_1_1RandomForestOptions.html">RandomForestOptions</a> in the C++ documentation for the meaning of the other parameters.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>void * __init__(class boost::python::api::object,class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;,class vigra::NumpyArray&lt;1,unsigned int,struct vigra::StridedArrayTag&gt; [,int=255 [,int=0 [,int=1 [,int=0 [,float=1.0 [,bool=True [,bool=False]]]]]]])</dd>
</dl>
</dd>
</dl>
<dl class="method">
<dt id="vigra.learning.RandomForestOld.featureCount">
<tt class="descname">featureCount</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForestOld.featureCount" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>featureCount( (RandomForestOld)arg1) -&gt; int :</dt>
<dd><p class="first">Returns the number of features the RandomForest works with.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int featureCount(class vigra::RandomForestDeprec&lt;unsigned int&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForestOld.labelCount">
<tt class="descname">labelCount</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForestOld.labelCount" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>labelCount( (RandomForestOld)arg1) -&gt; int :</dt>
<dd><p class="first">Returns the number of labels, the RanfomForest knows.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int labelCount(class vigra::RandomForestDeprec&lt;unsigned int&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForestOld.predictLabels">
<tt class="descname">predictLabels</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForestOld.predictLabels" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>predictLabels( (RandomForestOld)arg1, (object)testData [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Predict labels on &#8216;testData&#8217;.The output is an array containing a labels for every test samples.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray predictLabels(class vigra::RandomForestDeprec&lt;unsigned int&gt;,class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,unsigned int,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForestOld.predictProbabilities">
<tt class="descname">predictProbabilities</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForestOld.predictProbabilities" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>predictProbabilities( (RandomForestOld)arg1, (object)testData [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Predict probabilities for different classes on &#8216;testData&#8217;.The output is an array containing a probability for every test sample and class.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray predictProbabilities(class vigra::RandomForestDeprec&lt;unsigned int&gt;,class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt; [,class vigra::NumpyArray&lt;2,float,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="vigra.learning.RandomForestOld.treeCount">
<tt class="descname">treeCount</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.learning.RandomForestOld.treeCount" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>treeCount( (RandomForestOld)arg1) -&gt; int :</dt>
<dd><p class="first">Returns the &#8216;treeCount&#8217;, that was set when constructing the RandomForest.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>int treeCount(class vigra::RandomForestDeprec&lt;unsigned int&gt; {lvalue})</dd>
</dl>
</dd>
</dl>
</dd></dl>

</dd></dl>

</div>
<div class="section" id="module-vigra.noise">
<h2><a class="toc-backref" href="#id183">Noise Estimation and Normalization</a><a class="headerlink" href="#module-vigra.noise" title="Permalink to this headline">¶</a></h2>
<p>The module vigra.noise provides noise estimation and normalization according to a
method proposed by Foerstner.</p>
<dl class="function">
<dt id="vigra.noise.linearNoiseNormalization">
<tt class="descclassname">vigra.noise.</tt><tt class="descname">linearNoiseNormalization</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.noise.linearNoiseNormalization" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>linearNoiseNormalization( (object)image, (float)a0, (float)a1 [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Noise normalization by means of an estimated linear noise model.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__NoiseNormalization.html#g8c7570ab8ca1cab600008b47f5b66723">linearNoiseNormalization</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray linearNoiseNormalization(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.noise.linearNoiseNormalizationEstimated">
<tt class="descclassname">vigra.noise.</tt><tt class="descname">linearNoiseNormalizationEstimated</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.noise.linearNoiseNormalizationEstimated" title="Permalink to this definition">¶</a></dt>
<dd><p>linearNoiseNormalizationEstimated( (object)image [, (bool)useGradient=True [, (int)windowRadius=6 [, (int)clusterCount=10 [, (float)averagingQuantile=0.80000000000000004 [, (float)noiseEstimationQuantile=1.5 [, (float)noiseVarianceInitialGuess=10.0 [, (object)out=None]]]]]]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray linearNoiseNormalizationEstimated(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,bool=True [,unsigned int=6 [,unsigned int=10 [,double=0.80000000000000004 [,double=1.5 [,double=10.0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]]])</dd>
</dl>
</blockquote>
</dd></dl>

<dl class="function">
<dt id="vigra.noise.noiseVarianceClustering">
<tt class="descclassname">vigra.noise.</tt><tt class="descname">noiseVarianceClustering</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.noise.noiseVarianceClustering" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>noiseVarianceClustering( (object)image [, (bool)useGradient=True [, (int)windowRadius=6 [, (int)clusterCount=10 [, (float)averagingQuantile=0.80000000000000004 [, (float)noiseEstimationQuantile=1.5 [, (float)noiseVarianceInitialGuess=10.0 [, (object)out=None]]]]]]]) -&gt; object :</dt>
<dd><p class="first">Determine the noise variance as a function of the image intensity and cluster the results.
This operator first calls noiseVarianceEstimation() to obtain a sequence of intensity/variance pairs,
which are then clustered using the median cut algorithm. Then the cluster centers (i.e. average variance vs. average intensity)
are determined and returned in the result sequence.</p>
<p>Since the length of the resulting array is not known beforhand, it cannot be written into an preallocated array
(the &#8220;out&#8221; argument in most other vigra python functions)
.
For details see the vigra documentation <a class="reference external" href="../../doc/vigra/group__NoiseNormalization.html#g929896a95891b85875221c4a120e16ae">noiseVarianceClustering</a>.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray noiseVarianceClustering(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,bool=True [,unsigned int=6 [,unsigned int=10 [,double=0.80000000000000004 [,double=1.5 [,double=10.0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.noise.noiseVarianceEstimation">
<tt class="descclassname">vigra.noise.</tt><tt class="descname">noiseVarianceEstimation</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.noise.noiseVarianceEstimation" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>noiseVarianceEstimation( (object)image [, (bool)useGradient=True [, (int)windowRadius=6 [, (int)clusterCount=10 [, (float)averagingQuantile=0.80000000000000004 [, (float)noiseEstimationQuantile=1.5 [, (float)noiseVarianceInitialGuess=10.0 [, (object)out=None]]]]]]]) -&gt; object :</dt>
<dd><p class="first">Determine the noise variance as a function of the image intensity.</p>
<p>Returns an array with the means in the first column and the variances in the second column.
Since the length of the resulting array is not known beforhand, it can not be written into an preallocated array
(the &#8220;out&#8221; argument in most other vigra python functions.</p>
<p>For details see the vigra documentation <a class="reference external" href="../../doc/vigra/group__NoiseNormalization.html#gad0bc420d9953e34184d9f6794e77eb1">noiseVarianceEstimation</a>.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray noiseVarianceEstimation(class vigra::NumpyArray&lt;2,struct vigra::Singleband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,bool=True [,unsigned int=6 [,unsigned int=10 [,double=0.80000000000000004 [,double=1.5 [,double=10.0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.noise.nonparametricNoiseNormalization">
<tt class="descclassname">vigra.noise.</tt><tt class="descname">nonparametricNoiseNormalization</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.noise.nonparametricNoiseNormalization" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>nonparametricNoiseNormalization( (object)image [, (bool)useGradient=True [, (int)windowRadius=6 [, (int)clusterCount=10 [, (float)averagingQuantile=0.80000000000000004 [, (float)noiseEstimationQuantile=1.5 [, (float)noiseVarianceInitialGuess=10.0 [, (object)out=None]]]]]]]) -&gt; object :</dt>
<dd><p class="first">Noise normalization by means of an estimated non-parametric noise model.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__NoiseNormalization.html#g7f9c11f6d39059c01dd077b1d90cefe0">nonparametricNoiseNormalization</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray nonparametricNoiseNormalization(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,bool=True [,unsigned int=6 [,unsigned int=10 [,double=0.80000000000000004 [,double=1.5 [,double=10.0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]]])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.noise.quadraticNoiseNormalization">
<tt class="descclassname">vigra.noise.</tt><tt class="descname">quadraticNoiseNormalization</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.noise.quadraticNoiseNormalization" title="Permalink to this definition">¶</a></dt>
<dd><dl class="docutils">
<dt>quadraticNoiseNormalization( (object)image, (float)a0, (float)a1, (float)a2 [, (object)out=None]) -&gt; object :</dt>
<dd><p class="first">Noise normalization by means of an estimated quadratic noise model.</p>
<p>For details see <a class="reference external" href="../../doc/vigra/group__NoiseNormalization.html#gaade18df9c87f3e3b72418dfa0efecaf">quadraticNoiseNormalization</a> in the vigra C++ documentation.</p>
<dl class="last docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray quadraticNoiseNormalization(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;,double,double,double [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None])</dd>
</dl>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="vigra.noise.quadraticNoiseNormalizationEstimated">
<tt class="descclassname">vigra.noise.</tt><tt class="descname">quadraticNoiseNormalizationEstimated</tt><big>(</big><big>)</big><a class="headerlink" href="#vigra.noise.quadraticNoiseNormalizationEstimated" title="Permalink to this definition">¶</a></dt>
<dd><p>quadraticNoiseNormalizationEstimated( (object)image [, (bool)useGradient=True [, (int)windowRadius=6 [, (int)clusterCount=10 [, (float)averagingQuantile=0.80000000000000004 [, (float)noiseEstimationQuantile=1.5 [, (float)noiseVarianceInitialGuess=10.0 [, (object)out=None]]]]]]]) -&gt; object :</p>
<blockquote>
<dl class="docutils">
<dt>C++ signature :</dt>
<dd>class vigra::NumpyAnyArray quadraticNoiseNormalizationEstimated(class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt; [,bool=True [,unsigned int=6 [,unsigned int=10 [,double=0.80000000000000004 [,double=1.5 [,double=10.0 [,class vigra::NumpyArray&lt;3,struct vigra::Multiband&lt;float&gt;,struct vigra::StridedArrayTag&gt;=None]]]]]]])</dd>
</dl>
</blockquote>
</dd></dl>

</div>
</div>
<div class="section" id="indices-and-tables">
<h1><a class="toc-backref" href="#id184">Indices and tables</a><a class="headerlink" href="#indices-and-tables" title="Permalink to this headline">¶</a></h1>
<ul>
<li><p class="first"><a class="reference external" href="genindex.html"><em>Index</em></a></p>
</li>
<li><p class="first"><a class="reference external" href="modindex.html"><em>Module Index</em></a></p>
</li>
<li><p class="first"><a class="reference external" href="search.html"><em>Search Page</em></a></p>
<blockquote>
</blockquote>
</li>
</ul>
</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
            <h3><a href="#">Table Of Contents</a></h3>
            <ul>
<li><a class="reference external" href="#">Vigranumpy Reference</a><ul>
<li><a class="reference external" href="#introduction">Introduction</a></li>
<li><a class="reference external" href="#image-and-volume-data-structures">Image and Volume Data Structures</a></li>
<li><a class="reference external" href="#module-vigra.impex">Import and Export Functions</a></li>
<li><a class="reference external" href="#module-vigra.ufunc">Mathematical Functions and Type Coercion</a></li>
<li><a class="reference external" href="#module-vigra.colors">Color and Intensity Manipulation</a></li>
<li><a class="reference external" href="#module-vigra.filters">Filters</a></li>
<li><a class="reference external" href="#module-vigra.sampling">Sampling</a></li>
<li><a class="reference external" href="#module-vigra.fourier">Fourier Transforms</a></li>
<li><a class="reference external" href="#module-vigra.analysis">Image Analysis</a></li>
<li><a class="reference external" href="#module-vigra.learning">Machine Learning</a></li>
<li><a class="reference external" href="#module-vigra.noise">Noise Estimation and Normalization</a></li>
</ul>
</li>
<li><a class="reference external" href="#indices-and-tables">Indices and tables</a></li>
</ul>

            <h3>This Page</h3>
            <ul class="this-page-menu">
              <li><a href="_sources/index.txt"
                     rel="nofollow">Show Source</a></li>
            </ul>
          <div id="searchbox" style="display: none">
            <h3>Quick search</h3>
              <form class="search" action="search.html" method="get">
                <input type="text" name="q" size="18" />
                <input type="submit" value="Go" />
                <input type="hidden" name="check_keywords" value="yes" />
                <input type="hidden" name="area" value="default" />
              </form>
              <p class="searchtip" style="font-size: 90%">
              Enter search terms or a module, class or function name.
              </p>
          </div>
          <script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="modindex.html" title="Global Module Index"
             >modules</a> |</li>
        <li><a href="#">vigranumpy v1.7.0 documentation</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
      &copy; Copyright 2010, Ullrich Koethe and others.
      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.5.
    </div>
  </body>
</html>