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

vigra/basicimageview.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 /*    The VIGRA Website is                                              */
00008 /*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
00009 /*    Please direct questions, bug reports, and contributions to        */
00010 /*        ullrich.koethe@iwr.uni-heidelberg.de    or                    */
00011 /*        vigra@informatik.uni-hamburg.de                               */
00012 /*                                                                      */
00013 /*    Permission is hereby granted, free of charge, to any person       */
00014 /*    obtaining a copy of this software and associated documentation    */
00015 /*    files (the "Software"), to deal in the Software without           */
00016 /*    restriction, including without limitation the rights to use,      */
00017 /*    copy, modify, merge, publish, distribute, sublicense, and/or      */
00018 /*    sell copies of the Software, and to permit persons to whom the    */
00019 /*    Software is furnished to do so, subject to the following          */
00020 /*    conditions:                                                       */
00021 /*                                                                      */
00022 /*    The above copyright notice and this permission notice shall be    */
00023 /*    included in all copies or substantial portions of the             */
00024 /*    Software.                                                         */
00025 /*                                                                      */
00026 /*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
00027 /*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
00028 /*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
00029 /*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
00030 /*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
00031 /*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
00032 /*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
00033 /*    OTHER DEALINGS IN THE SOFTWARE.                                   */                
00034 /*                                                                      */
00035 /************************************************************************/
00036 
00037 #ifndef VIGRA_BASICIMAGEVIEW_HXX
00038 #define VIGRA_BASICIMAGEVIEW_HXX
00039 
00040 #include "imageiterator.hxx"
00041 #include "initimage.hxx"
00042 
00043 namespace vigra {
00044 
00045 
00046 /********************************************************/
00047 /*                                                      */
00048 /*                     BasicImageView                   */
00049 /*                                                      */
00050 /********************************************************/
00051 
00052 /** \brief BasicImage using foreign memory.
00053 
00054     This class provides the same interface as \ref vigra::BasicImage
00055     (with the exception of <tt>resize()</tt>) but the image's
00056     memory is provided from the outside instead of allocated internally.
00057     
00058     A <tt>BasicImageView</tt> can also be created from a 
00059     \ref vigra::MultiArrayView with the appropriate shape -- see
00060     \ref MultiArrayToImage.
00061     
00062     <b>\#include</b> <<a href="basicimageview_8hxx-source.html">vigra/basicimageview.hxx</a>>
00063 
00064     Namespace: vigra
00065 */
00066 template <class PIXELTYPE>
00067 class BasicImageView
00068 {
00069   public:
00070 
00071         /** the BasicImageView's pixel type
00072         */
00073     typedef PIXELTYPE value_type;
00074 
00075         /** the BasicImageView's pixel type
00076         */
00077     typedef PIXELTYPE PixelType;
00078 
00079         /** the BasicImageView's reference type (i.e. the
00080             return type of image[diff] and image(dx,dy))
00081         */
00082     typedef PIXELTYPE &       reference;
00083 
00084         /** the BasicImageView's const reference type (i.e. the
00085             return type of image[diff] and image(dx,dy) when image is const)
00086         */
00087     typedef PIXELTYPE const & const_reference;
00088 
00089         /** the BasicImageView's pointer type
00090         */
00091     typedef PIXELTYPE *       pointer;
00092 
00093         /** the BasicImageView's const pointer type
00094         */
00095     typedef PIXELTYPE const * const_pointer;
00096 
00097         /** the BasicImageView's 1D random access iterator
00098             (note: lower case 'iterator' is a STL compatible 1D random
00099              access iterator, don't confuse with capitalized Iterator)
00100         */
00101     typedef PIXELTYPE * iterator;
00102 
00103         /** deprecated, use <TT>iterator</TT> instead
00104         */
00105     typedef PIXELTYPE * ScanOrderIterator;
00106 
00107         /** the BasicImageView's 1D random access const iterator
00108             (note: lower case 'const_iterator' is a STL compatible 1D
00109             random access const iterator)
00110         */
00111     typedef PIXELTYPE const * const_iterator;
00112 
00113         /** deprecated, use <TT>const_iterator</TT> instead
00114         */
00115     typedef PIXELTYPE const * ConstScanOrderIterator;
00116 
00117         /** the BasicImageView's 2D random access iterator ('traverser')
00118         */
00119     typedef ImageIterator<value_type> traverser;
00120 
00121         /** deprecated, use <TT>traverser</TT> instead
00122         */
00123     typedef ImageIterator<value_type> Iterator;
00124 
00125         /** the BasicImageView's 2D random access const iterator ('const traverser')
00126         */
00127     typedef ConstImageIterator<value_type> const_traverser;
00128 
00129         /** deprecated, use <TT>const_traverser</TT> instead
00130         */
00131     typedef ConstImageIterator<value_type> ConstIterator;
00132 
00133         /** the row iterator associated with the traverser
00134         */
00135     typedef typename traverser::row_iterator row_iterator;
00136 
00137         /** the const row iterator associated with the const_traverser
00138         */
00139     typedef typename const_traverser::row_iterator const_row_iterator;
00140 
00141         /** the column iterator associated with the traverser
00142         */
00143     typedef typename traverser::column_iterator column_iterator;
00144 
00145         /** the const column iterator associated with the const_traverser
00146         */
00147     typedef typename const_traverser::column_iterator const_column_iterator;
00148 
00149         /** the BasicImageView's difference type (argument type of image[diff])
00150         */
00151     typedef Diff2D difference_type;
00152 
00153          /** the BasicImageView's size type (result type of image.size())
00154         */
00155     typedef Size2D size_type;
00156 
00157        /** the BasicImageView's default accessor
00158         */
00159     typedef typename
00160           IteratorTraits<traverser>::DefaultAccessor Accessor;
00161 
00162         /** the BasicImageView's default const accessor
00163         */
00164     typedef typename
00165           IteratorTraits<const_traverser>::DefaultAccessor ConstAccessor;
00166 
00167         /** construct image of size 0x0
00168         */
00169     BasicImageView()
00170     : data_(0),
00171       width_(0),
00172       height_(0),
00173       stride_(0)
00174     {}
00175 
00176         /** construct view of size w x h
00177         */
00178     BasicImageView(const_pointer data, int w, int h, int stride = 0)
00179     : data_(const_cast<pointer>(data)),
00180       width_(w),
00181       height_(h),
00182       stride_(stride == 0 ? w : stride)
00183     {}
00184 
00185         /** construct view of size size.x x size.y
00186         */
00187     BasicImageView(const_pointer data, difference_type const & size, int stride = 0)
00188     : data_(const_cast<pointer>(data)),
00189       width_(size.x),
00190       height_(size.y),
00191       stride_(stride == 0 ? size.x : stride)
00192     {}
00193 
00194         /** set Image with const value
00195         */
00196     BasicImageView & init(value_type const & pixel)
00197     {
00198         initImage(upperLeft(), lowerRight(), accessor(), pixel);
00199 
00200         return *this;
00201     }
00202 
00203         /** width of Image
00204         */
00205     int width() const
00206     {
00207         return width_;
00208     }
00209 
00210         /** height of Image
00211         */
00212     int height() const
00213     {
00214         return height_;
00215     }
00216 
00217         /** stride of Image. 
00218             Memory offset between the start of two successive rows.
00219         */
00220     int stride() const
00221     {
00222         return stride_;
00223     }
00224 
00225         /** size of Image
00226         */
00227     size_type size() const
00228     {
00229         return size_type(width(), height());
00230     }
00231 
00232         /** test whether a given coordinate is inside the image
00233         */
00234     bool isInside(difference_type const & d) const
00235     {
00236         return d.x >= 0 && d.y >= 0 &&
00237                d.x < width() && d.y < height();
00238     }
00239 
00240         /** access pixel at given location. <br>
00241         usage: <TT> value_type value = image[Diff2D(1,2)] </TT>
00242         */
00243     reference operator[](difference_type const & d)
00244     {
00245         return data_[d.y*stride_ + d.x];
00246     }
00247 
00248         /** read pixel at given location. <br>
00249         usage: <TT> value_type value = image[Diff2D(1,2)] </TT>
00250         */
00251     const_reference operator[](difference_type const & d) const
00252     {
00253         return data_[d.y*stride_ + d.x];
00254     }
00255 
00256         /** access pixel at given location. <br>
00257         usage: <TT> value_type value = image(1,2) </TT>
00258         */
00259     reference operator()(int dx, int dy)
00260     {
00261         return data_[dy*stride_ + dx];
00262     }
00263 
00264         /** read pixel at given location. <br>
00265         usage: <TT> value_type value = image(1,2) </TT>
00266         */
00267     const_reference operator()(int dx, int dy) const
00268     {
00269         return data_[dy*stride_ + dx];
00270     }
00271 
00272         /** access pixel at given location.
00273             Note that the 'x' index is the trailing index. <br>
00274         usage: <TT> value_type value = image[2][1] </TT>
00275         */
00276     pointer operator[](int dy)
00277     {
00278         return data_ + dy*stride_;
00279     }
00280 
00281         /** read pixel at given location.
00282             Note that the 'x' index is the trailing index. <br>
00283         usage: <TT> value_type value = image[2][1] </TT>
00284         */
00285     const_pointer operator[](int dy) const
00286     {
00287         return data_ + dy*stride_;
00288     }
00289 
00290         /** init 2D random access iterator poining to upper left pixel
00291         */
00292     traverser upperLeft()
00293     {
00294         return traverser(data_, stride_);
00295     }
00296 
00297         /** init 2D random access iterator poining to
00298          pixel(width, height), i.e. one pixel right and below lower right
00299          corner of the image as is common in C/C++.
00300         */
00301     traverser lowerRight()
00302     {
00303         return upperLeft() + size();
00304     }
00305 
00306         /** init 2D random access const iterator poining to upper left pixel
00307         */
00308     const_traverser upperLeft() const
00309     {
00310         return const_traverser(data_, stride_);
00311     }
00312 
00313         /** init 2D random access const iterator poining to
00314          pixel(width, height), i.e. one pixel right and below lower right
00315          corner of the image as is common in C/C++.
00316         */
00317     const_traverser lowerRight() const
00318     {
00319         return upperLeft() + size();
00320     }
00321 
00322         /** init 1D random access iterator pointing to first pixel.
00323             Note: Only works if stride equals width.
00324         */
00325     iterator begin()
00326     {
00327         vigra_precondition(stride_ == width_,
00328             "BasicImageView::begin(): "
00329             "can only create scan order iterator if width() == stride().");
00330         return data_;
00331     }
00332 
00333         /** init 1D random access iterator pointing past the end.
00334             Note: Only works if stride equals width.
00335         */
00336     iterator end()
00337     {
00338         vigra_precondition(stride_ == width_,
00339             "BasicImageView::end(): "
00340             "can only create scan order iterator if width() == stride().");
00341         return data_ + width() * height();
00342     }
00343 
00344         /** init 1D random access const iterator pointing to first pixel.
00345             Note: Only works if stride equals width.
00346         */
00347     const_iterator begin() const
00348     {
00349         vigra_precondition(stride_ == width_,
00350             "BasicImageView::begin(): "
00351             "can only create scan order iterator if width() == stride().");
00352         return data_;
00353     }
00354 
00355         /** init 1D random access const iterator pointing past the end.
00356             Note: Only works if stride equals width.
00357         */
00358     const_iterator end() const
00359     {
00360         vigra_precondition(stride_ == width_,
00361             "BasicImageView::end(): "
00362             "can only create scan order iterator if width() == stride().");
00363         return data_ + width() * height();
00364     }
00365 
00366         /** init 1D random access iterator pointing to first pixel of row \a y
00367         */
00368     row_iterator rowBegin(int y)
00369     {
00370         return data_ + stride_ * y;
00371     }
00372 
00373         /** init 1D random access iterator pointing past the end of row \a y
00374         */
00375     row_iterator rowEnd(int y)
00376     {
00377         return rowBegin(y) + width();
00378     }
00379 
00380         /** init 1D random access const iterator pointing to first pixel of row \a y
00381         */
00382     const_row_iterator rowBegin(int y) const
00383     {
00384         return data_ + stride_ * y;
00385     }
00386 
00387         /** init 1D random access const iterator pointing past the end of row \a y
00388         */
00389     const_row_iterator rowEnd(int y) const
00390     {
00391         return rowBegin(y) + width();
00392     }
00393 
00394         /** init 1D random access iterator pointing to first pixel of column \a x
00395         */
00396     column_iterator columnBegin(int x)
00397     {
00398         typedef typename column_iterator::BaseType Iter;
00399         return column_iterator(Iter(data_ + x, stride_));
00400     }
00401 
00402         /** init 1D random access iterator pointing past the end of column \a x
00403         */
00404     column_iterator columnEnd(int x)
00405     {
00406         return columnBegin(x) + height();
00407     }
00408 
00409         /** init 1D random access const iterator pointing to first pixel of column \a x
00410         */
00411     const_column_iterator columnBegin(int x) const 
00412     {
00413         typedef typename const_column_iterator::BaseType Iter;
00414         return const_column_iterator(Iter(data_ + x, stride_));
00415     }
00416 
00417         /** init 1D random access const iterator pointing past the end of column \a x
00418         */
00419     const_column_iterator columnEnd(int x) const 
00420     {
00421         return columnBegin(x) + height();
00422     }
00423 
00424         /** get a pointer to the internal data
00425         */
00426     const_pointer data() const
00427     {
00428         return data_;
00429     }
00430 
00431         /** return default accessor
00432         */
00433     Accessor accessor()
00434     {
00435         return Accessor();
00436     }
00437 
00438         /** return default const accessor
00439         */
00440     ConstAccessor accessor() const
00441     {
00442         return ConstAccessor();
00443     }
00444 
00445   private:
00446 
00447     pointer data_;
00448     int width_, height_, stride_;
00449 };
00450 
00451 
00452 /********************************************************/
00453 /*                                                      */
00454 /*              argument object factories               */
00455 /*                                                      */
00456 /********************************************************/
00457 
00458 template <class PixelType, class Accessor>
00459 inline triple<typename BasicImageView<PixelType>::const_traverser,
00460               typename BasicImageView<PixelType>::const_traverser, Accessor>
00461 srcImageRange(BasicImageView<PixelType> const & img, Accessor a)
00462 {
00463     return triple<typename BasicImageView<PixelType>::const_traverser,
00464                   typename BasicImageView<PixelType>::const_traverser,
00465           Accessor>(img.upperLeft(),
00466                     img.lowerRight(),
00467                     a);
00468 }
00469 
00470 template <class PixelType, class Accessor>
00471 inline triple<typename BasicImageView<PixelType>::const_traverser,
00472               typename BasicImageView<PixelType>::const_traverser, Accessor>
00473 srcImageRange(BasicImageView<PixelType> const & img, Rect2D const & roi, Accessor a)
00474 {
00475     vigra_precondition(roi.left() >= 0 && roi.top() >= 0 && 
00476                        roi.right() <= img.width() && roi.bottom() <= img.height(), 
00477                        "srcImageRange(): ROI rectangle outside image.");
00478     return triple<typename BasicImageView<PixelType>::const_traverser,
00479                   typename BasicImageView<PixelType>::const_traverser,
00480           Accessor>(img.upperLeft() + roi.upperLeft(),
00481                     img.upperLeft() + roi.lowerRight(),
00482                     a);
00483 }
00484 
00485 template <class PixelType, class Accessor>
00486 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
00487 srcImage(BasicImageView<PixelType> const & img, Accessor a)
00488 {
00489     return pair<typename BasicImageView<PixelType>::const_traverser,
00490                 Accessor>(img.upperLeft(), a);
00491 }
00492 
00493 template <class PixelType, class Accessor>
00494 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
00495 srcImage(BasicImageView<PixelType> const & img, Point2D const & ul, Accessor a)
00496 {
00497     vigra_precondition(img.isInside(ul), 
00498                        "srcImage(): ROI rectangle outside image.");
00499     return pair<typename BasicImageView<PixelType>::const_traverser,
00500                 Accessor>(img.upperLeft() + ul, a);
00501 }
00502 
00503 template <class PixelType, class Accessor>
00504 inline triple<typename BasicImageView<PixelType>::traverser,
00505               typename BasicImageView<PixelType>::traverser, Accessor>
00506 destImageRange(BasicImageView<PixelType> & img, Accessor a)
00507 {
00508     return triple<typename BasicImageView<PixelType>::traverser,
00509                   typename BasicImageView<PixelType>::traverser,
00510           Accessor>(img.upperLeft(),
00511                     img.lowerRight(),
00512                     a);
00513 }
00514 
00515 template <class PixelType, class Accessor>
00516 inline triple<typename BasicImageView<PixelType>::traverser,
00517               typename BasicImageView<PixelType>::traverser, Accessor>
00518 destImageRange(BasicImageView<PixelType> & img, Rect2D const & roi, Accessor a)
00519 {
00520     vigra_precondition(roi.left() >= 0 && roi.top() >= 0 && 
00521                        roi.right() <= img.width() && roi.bottom() <= img.height(), 
00522                        "destImageRange(): ROI rectangle outside image.");
00523     return triple<typename BasicImageView<PixelType>::traverser,
00524                   typename BasicImageView<PixelType>::traverser,
00525           Accessor>(img.upperLeft() + roi.upperLeft(),
00526                     img.upperLeft() + roi.lowerRight(),
00527                     a);
00528 }
00529 
00530 template <class PixelType, class Accessor>
00531 inline pair<typename BasicImageView<PixelType>::traverser, Accessor>
00532 destImage(BasicImageView<PixelType> & img, Accessor a)
00533 {
00534     return pair<typename BasicImageView<PixelType>::traverser,
00535                 Accessor>(img.upperLeft(), a);
00536 }
00537 
00538 template <class PixelType, class Accessor>
00539 inline pair<typename BasicImageView<PixelType>::traverser, Accessor>
00540 destImage(BasicImageView<PixelType> & img, Point2D const & ul, Accessor a)
00541 {
00542     vigra_precondition(img.isInside(ul), 
00543                        "destImage(): ROI rectangle outside image.");
00544     return pair<typename BasicImageView<PixelType>::traverser,
00545                 Accessor>(img.upperLeft() + ul, a);
00546 }
00547 
00548 template <class PixelType, class Accessor>
00549 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
00550 maskImage(BasicImageView<PixelType> const & img, Accessor a)
00551 {
00552     return pair<typename BasicImageView<PixelType>::const_traverser,
00553                 Accessor>(img.upperLeft(), a);
00554 }
00555 
00556 template <class PixelType, class Accessor>
00557 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
00558 maskImage(BasicImageView<PixelType> const & img, Point2D const & ul, Accessor a)
00559 {
00560     vigra_precondition(img.isInside(ul), 
00561                        "maskImage(): ROI rectangle outside image.");
00562     return pair<typename BasicImageView<PixelType>::const_traverser,
00563                 Accessor>(img.upperLeft() + ul, a);
00564 }
00565 
00566 /****************************************************************/
00567 
00568 template <class PixelType>
00569 inline triple<typename BasicImageView<PixelType>::const_traverser,
00570               typename BasicImageView<PixelType>::const_traverser,
00571               typename BasicImageView<PixelType>::ConstAccessor>
00572 srcImageRange(BasicImageView<PixelType> const & img)
00573 {
00574     return triple<typename BasicImageView<PixelType>::const_traverser,
00575                   typename BasicImageView<PixelType>::const_traverser,
00576                   typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(),
00577                                                                         img.lowerRight(),
00578                                                                         img.accessor());
00579 }
00580 
00581 template <class PixelType>
00582 inline triple<typename BasicImageView<PixelType>::const_traverser,
00583               typename BasicImageView<PixelType>::const_traverser,
00584               typename BasicImageView<PixelType>::ConstAccessor>
00585 srcImageRange(BasicImageView<PixelType> const & img, Rect2D const & roi)
00586 {
00587     vigra_precondition(roi.left() >= 0 && roi.top() >= 0 && 
00588                        roi.right() <= img.width() && roi.bottom() <= img.height(), 
00589                        "srcImageRange(): ROI rectangle outside image.");
00590     return triple<typename BasicImageView<PixelType>::const_traverser,
00591                   typename BasicImageView<PixelType>::const_traverser,
00592                   typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft() + roi.upperLeft(),
00593                                                                         img.upperLeft() + roi.lowerRight(),
00594                                                                         img.accessor());
00595 }
00596 
00597 template <class PixelType>
00598 inline pair< typename BasicImageView<PixelType>::const_traverser,
00599              typename BasicImageView<PixelType>::ConstAccessor>
00600 srcImage(BasicImageView<PixelType> const & img)
00601 {
00602     return pair<typename BasicImageView<PixelType>::const_traverser,
00603                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(),
00604                                                                       img.accessor());
00605 }
00606 
00607 template <class PixelType>
00608 inline pair< typename BasicImageView<PixelType>::const_traverser,
00609              typename BasicImageView<PixelType>::ConstAccessor>
00610 srcImage(BasicImageView<PixelType> const & img, Point2D const & ul)
00611 {
00612     vigra_precondition(img.isInside(ul), 
00613                        "srcImage(): ROI rectangle outside image.");
00614     return pair<typename BasicImageView<PixelType>::const_traverser,
00615                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft() + ul,
00616                                                                       img.accessor());
00617 }
00618 
00619 template <class PixelType>
00620 inline triple< typename BasicImageView<PixelType>::traverser,
00621                typename BasicImageView<PixelType>::traverser,
00622                typename BasicImageView<PixelType>::Accessor>
00623 destImageRange(BasicImageView<PixelType> & img)
00624 {
00625     return triple<typename BasicImageView<PixelType>::traverser,
00626                   typename BasicImageView<PixelType>::traverser,
00627                   typename BasicImageView<PixelType>::Accessor>(img.upperLeft(),
00628                                                                    img.lowerRight(),
00629                                                                    img.accessor());
00630 }
00631 
00632 template <class PixelType>
00633 inline triple< typename BasicImageView<PixelType>::traverser,
00634                typename BasicImageView<PixelType>::traverser,
00635                typename BasicImageView<PixelType>::Accessor>
00636 destImageRange(BasicImageView<PixelType> & img, Rect2D const & roi)
00637 {
00638     vigra_precondition(roi.left() >= 0 && roi.top() >= 0 && 
00639                        roi.right() <= img.width() && roi.bottom() <= img.height(), 
00640                        "destImageRange(): ROI rectangle outside image.");
00641     return triple<typename BasicImageView<PixelType>::traverser,
00642                   typename BasicImageView<PixelType>::traverser,
00643                   typename BasicImageView<PixelType>::Accessor>(img.upperLeft() + roi.upperLeft(),
00644                                                                    img.upperLeft() + roi.lowerRight(),
00645                                                                    img.accessor());
00646 }
00647 
00648 template <class PixelType>
00649 inline pair< typename BasicImageView<PixelType>::traverser,
00650              typename BasicImageView<PixelType>::Accessor>
00651 destImage(BasicImageView<PixelType> & img)
00652 {
00653     return pair<typename BasicImageView<PixelType>::traverser,
00654                 typename BasicImageView<PixelType>::Accessor>(img.upperLeft(),
00655                                                           img.accessor());
00656 }
00657 
00658 template <class PixelType>
00659 inline pair< typename BasicImageView<PixelType>::traverser,
00660              typename BasicImageView<PixelType>::Accessor>
00661 destImage(BasicImageView<PixelType> & img, Point2D const & ul)
00662 {
00663     vigra_precondition(img.isInside(ul), 
00664                        "destImage(): ROI rectangle outside image.");
00665     return pair<typename BasicImageView<PixelType>::traverser,
00666                 typename BasicImageView<PixelType>::Accessor>(img.upperLeft() + ul,
00667                                                                  img.accessor());
00668 }
00669 
00670 template <class PixelType>
00671 inline pair< typename BasicImageView<PixelType>::const_traverser,
00672              typename BasicImageView<PixelType>::ConstAccessor>
00673 maskImage(BasicImageView<PixelType> const & img)
00674 {
00675     return pair<typename BasicImageView<PixelType>::const_traverser,
00676                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(),
00677                                                                       img.accessor());
00678 }
00679 
00680 template <class PixelType>
00681 inline pair< typename BasicImageView<PixelType>::const_traverser,
00682              typename BasicImageView<PixelType>::ConstAccessor>
00683 maskImage(BasicImageView<PixelType> const & img, Point2D const & ul)
00684 {
00685     vigra_precondition(img.isInside(ul), 
00686                        "maskImage(): ROI rectangle outside image.");
00687     return pair<typename BasicImageView<PixelType>::const_traverser,
00688                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft() + ul,
00689                                                                       img.accessor());
00690 }
00691 
00692 } // namespace vigra
00693 
00694 #endif /* VIGRA_BASICIMAGEVIEW_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.6.0 (5 Nov 2009)