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

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