VIGRA - vigra/iteratortraits.hxx Source File

[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]

| vigra/iteratortraits.hxx |
--- | --- | ---

    00001 /************************************************************************/
    00002 /*                                                                      */
    00003 /*               Copyright 1998-2002 by Ullrich Koethe                  */
    00004 /*       Cognitive Systems Group, University of Hamburg, Germany        */
    00005 /*                                                                      */
    00006 /*    This file is part of the VIGRA computer vision library.           */
    00007 /*    ( Version 1.5.0, Dec 07 2006 )                                    */
    00008 /*    The VIGRA Website is                                              */
    00009 /*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
    00010 /*    Please direct questions, bug reports, and contributions to        */
    00011 /*        koethe@informatik.uni-hamburg.de          or                  */
    00012 /*        vigra@kogs1.informatik.uni-hamburg.de                         */
    00013 /*                                                                      */
    00014 /*    Permission is hereby granted, free of charge, to any person       */
    00015 /*    obtaining a copy of this software and associated documentation    */
    00016 /*    files (the "Software"), to deal in the Software without           */
    00017 /*    restriction, including without limitation the rights to use,      */
    00018 /*    copy, modify, merge, publish, distribute, sublicense, and/or      */
    00019 /*    sell copies of the Software, and to permit persons to whom the    */
    00020 /*    Software is furnished to do so, subject to the following          */
    00021 /*    conditions:                                                       */
    00022 /*                                                                      */
    00023 /*    The above copyright notice and this permission notice shall be    */
    00024 /*    included in all copies or substantial portions of the             */
    00025 /*    Software.                                                         */
    00026 /*                                                                      */
    00027 /*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
    00028 /*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
    00029 /*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
    00030 /*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
    00031 /*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
    00032 /*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
    00033 /*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
    00034 /*    OTHER DEALINGS IN THE SOFTWARE.                                   */
    00035 /*                                                                      */
    00036 /************************************************************************/
    00037
    00038
    00039 #ifndef VIGRA_ITERATORTRAITS_HXX
    00040 #define VIGRA_ITERATORTRAITS_HXX
    00041
    00042 #include "accessor.hxx"
    00043 #include "imageiteratoradapter.hxx"
    00044
    00045 namespace vigra {
    00046
    00047 /** \addtogroup ImageIterators
    00048 */
    00049 //@{
    00050 /** \brief Export associated information for each image iterator.
    00051
    00052     The IteratorTraits class contains the following fields:
    00053
    00054     \code
    00055     template <class T>
    00056     struct IteratorTraits
    00057     {
    00058         typedef T                                     Iterator;
    00059         typedef Iterator                              iterator;
    00060         typedef typename iterator::iterator_category  iterator_category;
    00061         typedef typename iterator::value_type         value_type;
    00062         typedef typename iterator::reference          reference;
    00063         typedef typename iterator::index_reference    index_reference;
    00064         typedef typename iterator::pointer            pointer;
    00065         typedef typename iterator::difference_type    difference_type;
    00066         typedef typename iterator::row_iterator       row_iterator;
    00067         typedef typename iterator::column_iterator    column_iterator;
    00068         typedef StandardAccessor<value_type>          DefaultAccessor;
    00069         typedef StandardAccessor<value_type>          default_accessor;
    00070
    00071         typedef VigraTrueType/VigraFalseType          hasConstantStrides;
    00072     };
    00073     \endcode
    00074
    00075     By (partially) specializing this template for an iterator class
    00076     the defaults given above can be changed as appropriate. For example, iterators
    00077     for rgb images are associated with <TT>RGBAccessor<value_type></TT>
    00078     instead of <TT>StandardAccessor<value_type></TT>. To get the accessor
    00079     associated with a given iterator, use code like this:
    00080
    00081     \code
    00082     template <class Iterator>
    00083     void foo(Iterator i)
    00084     {
    00085         typedef typename IteratorTraits<Iterator>::DefaultAccessor Accessor;
    00086         Accessor a;
    00087         ...
    00088     }
    00089     \endcode
    00090
    00091     This technique is, for example, used by the
    00092     \ref IteratorBasedArgumentObjectFactories. The possibility to retrieve the default accessor by means of a traits
    00093     class is especially important since this information is not
    00094     contained in the iterator directly.
    00095
    00096     The member <tt>hasConstantStrides</tt> is useful for certain
    00097     optimizations: it helps to decide whether we can replace iterator
    00098     operations such as <tt>iter++</tt> ot <tt>iter =+ n</tt> with
    00099     corresponding pointer operations (which may be faster), where
    00100     the pointer is obtained as the address of iterator's pointee
    00101     (the object the iterator currently  refers to).
    00102     This flag would be tt>VigraFalseType</tt> for a
    00103     <tt>std::list&lt;int&gt;::iterator</tt>, but is <tt>VigraTrueType</tt>
    00104     for most VIGRA iterators.
    00105
    00106     <b>\#include</b> "<a href="iteratortraits_8hxx-source.html">vigra/iteratortraits.hxx</a>"
    00107     Namespace: vigra
    00108 */
    00109 template <class T>
    00110 struct IteratorTraits
    00111 {
    00112     typedef T                                          Iterator;
    00113     typedef Iterator                                   iterator;
    00114     typedef typename iterator::iterator_category       iterator_category;
    00115     typedef typename iterator::value_type              value_type;
    00116     typedef typename iterator::reference               reference;
    00117     typedef typename iterator::index_reference         index_reference;
    00118     typedef typename iterator::pointer                 pointer;
    00119     typedef typename iterator::difference_type         difference_type;
    00120     typedef typename iterator::row_iterator            row_iterator;
    00121     typedef typename iterator::column_iterator         column_iterator;
    00122     typedef typename
    00123         AccessorTraits<value_type>::default_accessor   DefaultAccessor;
    00124     typedef DefaultAccessor                            default_accessor;
    00125
    00126     // default: disable the constant strides optimization
    00127     typedef VigraFalseType                             hasConstantStrides;
    00128 };
    00129
    00130 template <class T>
    00131 struct IteratorTraitsBase
    00132 {
    00133     typedef T                                     Iterator;
    00134     typedef Iterator                              iterator;
    00135     typedef typename iterator::iterator_category  iterator_category;
    00136     typedef typename iterator::value_type         value_type;
    00137     typedef typename iterator::reference          reference;
    00138     typedef typename iterator::index_reference    index_reference;
    00139     typedef typename iterator::pointer            pointer;
    00140     typedef typename iterator::difference_type    difference_type;
    00141     typedef typename iterator::row_iterator       row_iterator;
    00142     typedef typename iterator::column_iterator    column_iterator;
    00143 };
    00144
    00145 /***********************************************************/
    00146
    00147 /** \page ArgumentObjectFactories Argument Object Factories
    00148
    00149     Factory functions to create argument objects which simplify long argument lists.
    00150
    00151     <DL>
    00152     <DT>
    00153         <IMG BORDER=0 ALT="-" SRC="documents/bullet.gif">
    00154         \ref ImageBasedArgumentObjectFactories
    00155         <DD>
    00156     <DT>
    00157         <IMG BORDER=0 ALT="-" SRC="documents/bullet.gif">
    00158         \ref MultiArrayBasedArgumentObjectFactories
    00159         <DD>
    00160     <DT>
    00161         <IMG BORDER=0 ALT="-" SRC="documents/bullet.gif">
    00162         \ref IteratorBasedArgumentObjectFactories
    00163         <DD>
    00164     </DL>
    00165
    00166     Long argument lists provide for greater flexibility of functions,
    00167     but they are also tedious and error prone, when we don't need
    00168     the flexibility. Thus, we define argument objects which
    00169     automatically provide reasonable defaults for those arguments that we
    00170     didn't specify explicitly.
    00171
    00172     The argument objects are created via a number of factory functions.
    00173     Since these functions have descriptive names, they also serve
    00174     to improve readability: the name of each factory tells te purpose of its
    00175     argument object.
    00176
    00177     Consider the following example. Without argument objects we had to
    00178     write something like this (cf. \ref copyImageIf()):
    00179
    00180     \code
    00181     vigra::BImage img1, img2, img3;
    00182
    00183     // fill img1 and img2 ...
    00184
    00185     vigra::copyImageIf(img1.upperLeft(), img1.lowerRight(), img1.accessor(),
    00186                 img2.upperLeft(), img2.accessor(),
    00187                 img3.upperLeft(), img3.accessor());
    00188     \endcode
    00189
    00190     Using the argument object factories, this becomes much shorter and
    00191     more readable:
    00192
    00193     \code
    00194     vigra::copyImageIf(srcImageRange(img1),
    00195                 maskImage(img2),
    00196                 destImage(img3));
    00197     \endcode
    00198
    00199     The names of the factories clearly tell which image is source, mask,
    00200     and destination. In addition, the suffix <TT>Range</TT> must be used
    00201     for those argument objects that need to specify the lower right
    00202     corner of the region of interest. Typically, this is only the first
    00203     source argument, but sometimes the first destiniation argument must
    00204     also contain a range.
    00205
    00206     The factory functions come in two flavours: Iterator based and
    00207     image based factories. Above we have seen the image based variant.
    00208     The iterator based variant would look like this:
    00209
    00210     \code
    00211     vigra::copyImageIf(srcIterRange(img1.upperLeft(), img1.lowerRight()),
    00212                 maskIter(img2.upperLeft()),
    00213                 destIter(img3.upperLeft()));
    00214     \endcode
    00215
    00216     These factory functions contain the word <TT>Iter</TT> instead of the word
    00217     <TT>Image</TT>,  They would normally be used if we couldn't access the
    00218     images (for example, within a function which got passed iterators)
    00219     or if we didn't want to operate on the entire image. The default
    00220     accessor is obtained via \ref vigra::IteratorTraits.
    00221
    00222     All factory functions also allow to specify accessors explicitly. This
    00223     is useful if we can't use the default accessor. This variant looks
    00224     like this:
    00225
    00226     \code
    00227     vigra::copyImageIf(srcImageRange(img1),
    00228                 maskImage(img2, MaskPredicateAccessor()),
    00229                 destImage(img3));
    00230     \endcode
    00231
    00232     or
    00233
    00234     \code
    00235     vigra::copyImageIf(srcIterRange(img1.upperLeft(), img1.lowerRight()),
    00236                 maskIter(img2.upperLeft(), MaskPredicateAccessor()),
    00237                 destIter(img3.upperLeft()));
    00238     \endcode
    00239
    00240     All versions can be mixed freely within one explession.
    00241     Technically, the argument objects are simply defined as
    00242     pairs and triples of iterators and accessor so that all algorithms
    00243     should declare a call interface version based on pairs and triples
    00244     (see for example \ref copyImageIf()).
    00245
    00246   \section ImageBasedArgumentObjectFactories Image Based Argument Object Factories
    00247
    00248     <b>Include:</b> automatically included with the image classes<br>
    00249     Namespace: vigra
    00250
    00251     These factories can be used to create argument objects when we
    00252     are given instances or subclasses of \ref vigra::BasicImage (see
    00253     \ref StandardImageTypes for instances defined per default).
    00254     These factory functions access <TT>img.upperLeft()</TT>,
    00255     <TT>img.lowerRight()</TT>, and <TT>img.accessor()</TT> to obtain the iterators
    00256     and accessor for the given image (unless the accessor is
    00257     given explicitly). The following factory functions are provided:
    00258
    00259     <table>
    00260     <tr><td>
    00261         \htmlonly
    00262         <th bgcolor="#f0e0c0" colspan=2 align=left>
    00263         \endhtmlonly
    00264         <TT>\ref vigra::BasicImage "vigra::BasicImage<SomeType>" img;</TT> or <br>
    00265          <TT>\ref vigra::BasicImageView "vigra::BasicImageView<SomeType>" img;</TT>
    00266          \htmlonly
    00267         </th>
    00268         \endhtmlonly
    00269     </td></tr>
    00270     <tr><td>
    00271
    00272     <TT>srcImageRange(img)</TT>
    00273     </td><td>
    00274         create argument object containing upper left, lower right, and
    00275         default accessor of source image
    00276
    00277     </td></tr>
    00278     <tr><td>
    00279
    00280     <TT>srcImageRange(img, Rect2D(...))</TT>
    00281     </td><td>
    00282         create argument object containing the ROI specified by <tt>\ref vigra::Rect2D</tt> and
    00283         default accessor of source image
    00284
    00285     </td></tr>
    00286     <tr><td>
    00287
    00288     <TT>srcImageRange(img, SomeAccessor())</TT>
    00289     </td><td>
    00290         create argument object containing upper left, lower right
    00291         of source image, and given accessor
    00292
    00293     </td></tr>
    00294     <tr><td>
    00295
    00296     <TT>srcImageRange(img, Rect2D(...), SomeAccessor())</TT>
    00297     </td><td>
    00298         create argument object containing the ROI specified by <tt>\ref vigra::Rect2D</tt> and
    00299         of source image, and given accessor
    00300
    00301     </td></tr>
    00302     <tr><td>
    00303
    00304     <TT>srcImage(img)</TT>
    00305     </td><td>
    00306         create argument object containing upper left, and
    00307         default accessor of source image
    00308
    00309     </td></tr>
    00310     <tr><td>
    00311
    00312     <TT>srcImage(img, Point2D(...))</TT>
    00313     </td><td>
    00314         create argument object with upper left at point given by <tt>\ref vigra::Point2D</tt>, and
    00315         default accessor of source image
    00316
    00317     </td></tr>
    00318     <tr><td>
    00319
    00320     <TT>srcImage(img, SomeAccessor())</TT>
    00321     </td><td>
    00322         create argument object containing upper left
    00323         of source image, and given accessor
    00324
    00325     </td></tr>
    00326     <tr><td>
    00327
    00328     <TT>srcImage(img, Point2D(...), SomeAccessor())</TT>
    00329     </td><td>
    00330         create argument object with upper left at point given by <tt>\ref vigra::Point2D</tt> of source image,
    00331         and given accessor
    00332
    00333     </td></tr>
    00334     <tr><td>
    00335
    00336     <TT>maskImage(img)</TT>
    00337     </td><td>
    00338         create argument object containing upper left, and
    00339         default accessor of mask image
    00340
    00341     </td></tr>
    00342      <tr><td>
    00343
    00344     <TT>maskImage(img, Point2D(...))</TT>
    00345     </td><td>
    00346         create argument object with upper left at point given by <tt>\ref vigra::Point2D</tt>, and
    00347         default accessor of mask image
    00348
    00349     </td></tr>
    00350    <tr><td>
    00351
    00352     <TT>maskImage(img, SomeAccessor())</TT>
    00353     </td><td>
    00354         create argument object containing upper left
    00355         of mask image, and given accessor
    00356
    00357     </td></tr>
    00358     <tr><td>
    00359
    00360     <TT>maskImage(img, Point2D(...), SomeAccessor())</TT>
    00361     </td><td>
    00362         create argument object with upper left at point given by <tt>\ref vigra::Point2D</tt> of mask image,
    00363         and given accessor
    00364
    00365     </td></tr>
    00366     <tr><td>
    00367
    00368     <TT>destImageRange(img)</TT>
    00369     </td><td>
    00370         create argument object containing upper left, lower right, and
    00371         default accessor of destination image
    00372
    00373     </td></tr>
    00374     <tr><td>
    00375
    00376     <TT>destImageRange(img, Rect2D(...))</TT>
    00377     </td><td>
    00378         create argument object containing the ROI specified by <tt>\ref vigra::Rect2D</tt> and
    00379         default accessor of destination image
    00380
    00381     </td></tr>
    00382     <tr><td>
    00383
    00384     <TT>destImageRange(img, SomeAccessor())</TT>
    00385     </td><td>
    00386         create argument object containing upper left, lower right
    00387         of destination image, and given accessor
    00388
    00389     </td></tr>
    00390     <tr><td>
    00391
    00392     <TT>destImageRange(img, Rect2D(...), SomeAccessor())</TT>
    00393     </td><td>
    00394         create argument object containing the ROI specified by <tt>\ref vigra::Rect2D</tt>
    00395         of destination image, and given accessor
    00396
    00397     </td></tr>
    00398      <tr><td>
    00399
    00400     <TT>destImage(img)</TT>
    00401     </td><td>
    00402         create argument object containing upper left, and
    00403         default accessor of destination image
    00404
    00405     </td></tr>
    00406      <tr><td>
    00407
    00408     <TT>destImage(img, Point2D(...))</TT>
    00409     </td><td>
    00410         create argument object with upper left at point given by <tt>\ref vigra::Point2D</tt>, and
    00411         default accessor of destination image
    00412
    00413     </td></tr>
    00414     <tr><td>
    00415
    00416     <TT>destImage(img, SomeAccessor())</TT>
    00417     </td><td>
    00418         create argument object containing upper left
    00419         of destination image, and given accessor
    00420
    00421     </td></tr>
    00422     <tr><td>
    00423
    00424     <TT>destImage(img, Point2D(...), SomeAccessor())</TT>
    00425     </td><td>
    00426         create argument object with upper left at point given by <tt>\ref vigra::Point2D</tt> of destination image,
    00427         and given accessor
    00428
    00429     </td></tr>
    00430     </table>
    00431
    00432
    00433   \section MultiArrayBasedArgumentObjectFactories MultiArrayView Based Argument Object Factories
    00434
    00435     <b>Include:</b> automatically included with
    00436        "<a href="multi__array_8hxx-source.html">vigra/multi_array.hxx</a>"<br>
    00437     Namespace: vigra
    00438
    00439     These factories can be used to create argument objects when we
    00440     are given instances or subclasses of \ref vigra::MultiArrayView.
    00441     These factory functions access <TT>array.traverser_begin()</TT>,
    00442     <TT>array.traverser_end()</TT> to obtain the iterators. If no accessor is
    00443     given, they use the <tt>AccessorTraits<T></tt> to determine the default
    00444     accessor associated with the array's value type <tt>T</tt>.
    00445     The following factory functions are provided:
    00446
    00447     <table>
    00448     <tr><td>
    00449         \htmlonly
    00450         <th bgcolor="#f0e0c0" colspan=2 align=left>
    00451         \endhtmlonly
    00452         <TT>\ref vigra::MultiArrayView "vigra::MultiArrayView<N, SomeType>" array;</TT>
    00453         \htmlonly
    00454         </th>
    00455         \endhtmlonly
    00456     </td></tr>
    00457     <tr><td>
    00458
    00459     <TT>srcMultiArrayRange(img)</TT>
    00460     </td><td>
    00461         create argument object containing a \ref vigra::MultiIterator
    00462         marking the begin of the array, a shape object giving the desired
    00463         shape of the array (possibly a subarray) and the default const accessor for
    00464         <tt>SomeType</tt>
    00465
    00466     </td></tr>
    00467     <tr><td>
    00468
    00469     <TT>srcMultiArrayRange(img, SomeAccessor())</TT>
    00470     </td><td>
    00471         create argument object containing a \ref vigra::MultiIterator
    00472         marking the begin of the array, a shape object giving the desired
    00473         shape of the array (possibly a subarray) and the given accessor
    00474
    00475     </td></tr>
    00476     <tr><td>
    00477
    00478     <TT>srcMultiArray(img)</TT>
    00479     </td><td>
    00480         create argument object containing a \ref vigra::MultiIterator
    00481         marking the begin of the array, and the default const accessor for
    00482         <tt>SomeType</tt>
    00483
    00484     </td></tr>
    00485     <tr><td>
    00486
    00487     <TT>srcMultiArray(img, SomeAccessor())</TT>
    00488     </td><td>
    00489         create argument object containing a \ref vigra::MultiIterator
    00490         marking the begin of the array and the given accessor
    00491
    00492     </td></tr>
    00493     <tr><td>
    00494
    00495     <TT>destMultiArrayRange(img)</TT>
    00496     </td><td>
    00497         create argument object containing a \ref vigra::MultiIterator
    00498         marking the begin of the array, a shape object giving the desired
    00499         shape of the array (possibly a subarray) and the default accessor for
    00500         <tt>SomeType</tt>
    00501
    00502     </td></tr>
    00503     <tr><td>
    00504
    00505     <TT>destMultiArrayRange(img, SomeAccessor())</TT>
    00506     </td><td>
    00507         create argument object containing a \ref vigra::MultiIterator's
    00508         marking the begin of the array, a shape object giving the desired
    00509         shape of the array (possibly a subarray) and the given accessor
    00510
    00511     </td></tr>
    00512     <tr><td>
    00513
    00514     <TT>destMultiArray(img)</TT>
    00515     </td><td>
    00516         create argument object containing a \ref vigra::MultiIterator
    00517         marking the begin of the array and the default accessor for
    00518         <tt>SomeType</tt>
    00519
    00520     </td></tr>
    00521     <tr><td>
    00522
    00523     <TT>destMultiArray(img, SomeAccessor())</TT>
    00524     </td><td>
    00525         create argument object containing a \ref vigra::MultiIterator's
    00526         marking the begin of the array and the given accessor
    00527
    00528     </td></tr>
    00529     </table>
    00530
    00531
    00532   \section IteratorBasedArgumentObjectFactories Iterator Based Argument Object Factories
    00533
    00534     <b>\#include</b> "<a href="iteratortraits_8hxx-source.html">vigra/iteratortraits.hxx</a>"
    00535     Namespace: vigra
    00536
    00537     These factories can be used to create argument objects when we
    00538     are given \ref ImageIterators.
    00539     These factory functions use \ref vigra::IteratorTraits to
    00540     get the default accessor for the given iterator unless the
    00541     accessor is given explicitly. The following factory functions
    00542     are provided:
    00543
    00544     <table>
    00545     <tr><td>
    00546         \htmlonly
    00547         <th bgcolor="#f0e0c0" colspan=2 align=left>
    00548         \endhtmlonly
    00549         <TT>\ref vigra::BasicImage::Iterator "vigra::BasicImage<SomeType>::Iterator" i1, i2;</TT>
    00550         \htmlonly
    00551         </th>
    00552         \endhtmlonly
    00553     </td></tr>
    00554     <tr><td>
    00555
    00556     <TT>srcIterRange(i1, i2)</TT>
    00557     </td><td>
    00558         create argument object containing the given iterators and
    00559         corresponding default accessor (for source image)
    00560
    00561     </td></tr>
    00562     <tr><td>
    00563
    00564     <TT>srcIterRange(i1, i2, SomeAccessor())</TT>
    00565     </td><td>
    00566         create argument object containing given iterators and
    00567         accessor (for source image)
    00568
    00569     </td></tr>
    00570     <tr><td>
    00571
    00572     <TT>srcIter(i1)</TT>
    00573     </td><td>
    00574         create argument object containing the given iterator and
    00575         corresponding default accessor (for source image)
    00576
    00577     </td></tr>
    00578     <tr><td>
    00579
    00580     <TT>srcIter(i1, SomeAccessor())</TT>
    00581     </td><td>
    00582         create argument object containing given iterator and
    00583         accessor (for source image)
    00584
    00585     </td></tr>
    00586     <tr><td>
    00587
    00588     <TT>maskIter(i1)</TT>
    00589     </td><td>
    00590         create argument object containing the given iterator and
    00591         corresponding default accessor (for mask image)
    00592
    00593     </td></tr>
    00594     <tr><td>
    00595
    00596     <TT>maskIter(i1, SomeAccessor())</TT>
    00597     </td><td>
    00598         create argument object containing given iterator and
    00599         accessor (for mask image)
    00600
    00601     </td></tr>
    00602     <tr><td>
    00603
    00604     <TT>destIterRange(i1, i2)</TT>
    00605     </td><td>
    00606         create argument object containing the given iterators and
    00607         corresponding default accessor (for destination image)
    00608
    00609     </td></tr>
    00610     <tr><td>
    00611
    00612     <TT>destIterRange(i1, i2, SomeAccessor())</TT>
    00613     </td><td>
    00614         create argument object containing given iterators and
    00615         accessor (for destination image)
    00616
    00617     </td></tr>
    00618     <tr><td>
    00619
    00620     <TT>destIter(i1)</TT>
    00621     </td><td>
    00622         create argument object containing the given iterator and
    00623         corresponding default accessor (for destination image)
    00624
    00625     </td></tr>
    00626     <tr><td>
    00627
    00628     <TT>destIter(i1, SomeAccessor())</TT>
    00629     </td><td>
    00630         create argument object containing given iterator and
    00631         accessor (for destination image)
    00632
    00633     </td></tr>
    00634     </table>
    00635 */
    00636
    00637 template <class Iterator, class Accessor>
    00638 inline triple<Iterator, Iterator, Accessor>
    00639 srcIterRange(Iterator const & upperleft, Iterator const & lowerright, Accessor a)
    00640 {
    00641     return triple<Iterator, Iterator, Accessor>(upperleft, lowerright, a);
    00642 }
    00643
    00644 template <class Iterator, class Accessor>
    00645 inline pair<Iterator, Accessor>
    00646 srcIter(Iterator const & upperleft, Accessor a)
    00647 {
    00648     return pair<Iterator, Accessor>(upperleft, a);
    00649 }
    00650
    00651 template <class Iterator, class Accessor>
    00652 inline pair<Iterator, Accessor>
    00653 maskIter(Iterator const & upperleft, Accessor a)
    00654 {
    00655     return pair<Iterator, Accessor>(upperleft, a);
    00656 }
    00657
    00658 template <class Iterator, class Accessor>
    00659 inline pair<Iterator, Accessor>
    00660 destIter(Iterator const & upperleft, Accessor a)
    00661 {
    00662     return pair<Iterator, Accessor>(upperleft, a);
    00663 }
    00664
    00665
    00666 template <class Iterator, class Accessor>
    00667 inline triple<Iterator, Iterator, Accessor>
    00668 destIterRange(Iterator const & upperleft, Iterator const & lowerright, Accessor a)
    00669 {
    00670     return triple<Iterator, Iterator, Accessor>(upperleft, lowerright, a);
    00671 }
    00672
    00673 template <class Iterator>
    00674 inline pair<Iterator, typename IteratorTraits<Iterator>::DefaultAccessor>
    00675 srcIter(Iterator const & upperleft)
    00676 {
    00677     return pair<Iterator, typename IteratorTraits<Iterator>::DefaultAccessor>(
    00678                   upperleft,
    00679                   typename IteratorTraits<Iterator>::DefaultAccessor());
    00680 }
    00681
    00682 template <class Iterator>
    00683 inline triple<Iterator, Iterator, typename IteratorTraits<Iterator>::DefaultAccessor>
    00684 srcIterRange(Iterator const & upperleft, Iterator const & lowerright)
    00685 {
    00686     return triple<Iterator, Iterator,
    00687                   typename IteratorTraits<Iterator>::DefaultAccessor>(
    00688                   upperleft, lowerright,
    00689                   typename IteratorTraits<Iterator>::DefaultAccessor());
    00690 }
    00691
    00692 template <class Iterator>
    00693 inline pair<Iterator, typename IteratorTraits<Iterator>::DefaultAccessor>
    00694 maskIter(Iterator const & upperleft)
    00695 {
    00696     return pair<Iterator, typename IteratorTraits<Iterator>::DefaultAccessor>(
    00697                   upperleft,
    00698                   typename IteratorTraits<Iterator>::DefaultAccessor());
    00699 }
    00700
    00701 template <class Iterator>
    00702 inline pair<Iterator, typename IteratorTraits<Iterator>::DefaultAccessor>
    00703 destIter(Iterator const & upperleft)
    00704 {
    00705     return pair<Iterator, typename IteratorTraits<Iterator>::DefaultAccessor>(
    00706                   upperleft,
    00707                   typename IteratorTraits<Iterator>::DefaultAccessor());
    00708 }
    00709
    00710 template <class Iterator>
    00711 inline triple<Iterator, Iterator, typename IteratorTraits<Iterator>::DefaultAccessor>
    00712 destIterRange(Iterator const & upperleft, Iterator const & lowerright)
    00713 {
    00714     return triple<Iterator, Iterator,
    00715                   typename IteratorTraits<Iterator>::DefaultAccessor>(
    00716                   upperleft, lowerright,
    00717                   typename IteratorTraits<Iterator>::DefaultAccessor());
    00718 }
    00719
    00720 //@}
    00721
    00722 } // namespace vigra
    00723
    00724 #endif // VIGRA_ITERATORTRAITS_HXX

© Ullrich Köthe (koethe@informatik.uni-hamburg.de) Cognitive Systems Group, University of Hamburg, Germany | html generated using doxygen and Python VIGRA 1.5.0 (7 Dec 2006)