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

vigra/iteratortraits.hxx VIGRA

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

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.9.0 (Tue Nov 6 2012)