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