36 #ifndef VIGRA_BASICIMAGEVIEW_HXX 
   37 #define VIGRA_BASICIMAGEVIEW_HXX 
   39 #include "imageiterator.hxx" 
   40 #include "initimage.hxx" 
   43 #ifdef VIGRA_CHECK_BOUNDS 
   44 #define VIGRA_ASSERT_INSIDE(diff) \ 
   45   vigra_precondition(this->isInside(diff), "Index out of bounds") 
   47 #define VIGRA_ASSERT_INSIDE(diff) 
   75 template <
class PIXELTYPE>
 
  188     : data_(const_cast<
pointer>(data)),
 
  197     : data_(const_cast<
pointer>(data)),
 
  245         return d.
x >= 0 && d.
y >= 0 &&
 
  254         VIGRA_ASSERT_INSIDE(d);
 
  255         return data_[d.
y*stride_ + d.
x];
 
  264         return data_[d.
y*stride_ + d.
x];
 
  273         return data_[dy*stride_ + dx];
 
  282         return data_[dy*stride_ + dx];
 
  292         return data_ + dy*stride_;
 
  302         return data_ + dy*stride_;
 
  342         vigra_precondition(stride_ == width_,
 
  343             "BasicImageView::begin(): " 
  344             "can only create scan order iterator if width() == stride().");
 
  353         vigra_precondition(stride_ == width_,
 
  354             "BasicImageView::end(): " 
  355             "can only create scan order iterator if width() == stride().");
 
  364         vigra_precondition(stride_ == width_,
 
  365             "BasicImageView::begin(): " 
  366             "can only create scan order iterator if width() == stride().");
 
  375         vigra_precondition(stride_ == width_,
 
  376             "BasicImageView::end(): " 
  377             "can only create scan order iterator if width() == stride().");
 
  385         return data_ + stride_ * y;
 
  399         return data_ + stride_ * y;
 
  413         typedef typename column_iterator::BaseType Iter;
 
  428         typedef typename const_column_iterator::BaseType Iter;
 
  463     std::ptrdiff_t width_, height_, stride_;
 
  473 template <
class PixelType, 
class Accessor>
 
  474 inline triple<typename BasicImageView<PixelType>::const_traverser,
 
  475               typename BasicImageView<PixelType>::const_traverser, Accessor>
 
  476 srcImageRange(BasicImageView<PixelType> 
const & img, Accessor a)
 
  478     return triple<typename BasicImageView<PixelType>::const_traverser,
 
  479                   typename BasicImageView<PixelType>::const_traverser,
 
  480           Accessor>(img.upperLeft(),
 
  485 template <
class PixelType, 
class Accessor>
 
  486 inline triple<typename BasicImageView<PixelType>::const_traverser,
 
  487               typename BasicImageView<PixelType>::const_traverser, Accessor>
 
  488 srcImageRange(BasicImageView<PixelType> 
const & img, Rect2D 
const & roi, Accessor a)
 
  490     vigra_precondition(roi.left() >= 0 && roi.top() >= 0 &&
 
  491                        roi.right() <= img.width() && roi.bottom() <= img.height(),
 
  492                        "srcImageRange(): ROI rectangle outside image.");
 
  493     return triple<typename BasicImageView<PixelType>::const_traverser,
 
  494                   typename BasicImageView<PixelType>::const_traverser,
 
  495           Accessor>(img.upperLeft() + roi.upperLeft(),
 
  496                     img.upperLeft() + roi.lowerRight(),
 
  500 template <
class PixelType, 
class Accessor>
 
  501 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
 
  502 srcImage(BasicImageView<PixelType> 
const & img, Accessor a)
 
  504     return pair<typename BasicImageView<PixelType>::const_traverser,
 
  505                 Accessor>(img.upperLeft(), a);
 
  508 template <
class PixelType, 
class Accessor>
 
  509 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
 
  510 srcImage(BasicImageView<PixelType> 
const & img, Point2D 
const & ul, Accessor a)
 
  512     vigra_precondition(img.isInside(ul),
 
  513                        "srcImage(): ROI rectangle outside image.");
 
  514     return pair<typename BasicImageView<PixelType>::const_traverser,
 
  515                 Accessor>(img.upperLeft() + ul, a);
 
  518 template <
class PixelType, 
class Accessor>
 
  519 inline triple<typename BasicImageView<PixelType>::traverser,
 
  520               typename BasicImageView<PixelType>::traverser, Accessor>
 
  521 destImageRange(BasicImageView<PixelType> & img, Accessor a)
 
  523     return triple<typename BasicImageView<PixelType>::traverser,
 
  524                   typename BasicImageView<PixelType>::traverser,
 
  525           Accessor>(img.upperLeft(),
 
  530 template <
class PixelType, 
class Accessor>
 
  531 inline triple<typename BasicImageView<PixelType>::traverser,
 
  532               typename BasicImageView<PixelType>::traverser, Accessor>
 
  533 destImageRange(BasicImageView<PixelType> & img, Rect2D 
const & roi, Accessor a)
 
  535     vigra_precondition(roi.left() >= 0 && roi.top() >= 0 &&
 
  536                        roi.right() <= img.width() && roi.bottom() <= img.height(),
 
  537                        "destImageRange(): ROI rectangle outside image.");
 
  538     return triple<typename BasicImageView<PixelType>::traverser,
 
  539                   typename BasicImageView<PixelType>::traverser,
 
  540           Accessor>(img.upperLeft() + roi.upperLeft(),
 
  541                     img.upperLeft() + roi.lowerRight(),
 
  545 template <
class PixelType, 
class Accessor>
 
  546 inline pair<typename BasicImageView<PixelType>::traverser, Accessor>
 
  547 destImage(BasicImageView<PixelType> & img, Accessor a)
 
  549     return pair<typename BasicImageView<PixelType>::traverser,
 
  550                 Accessor>(img.upperLeft(), a);
 
  553 template <
class PixelType, 
class Accessor>
 
  554 inline pair<typename BasicImageView<PixelType>::traverser, Accessor>
 
  555 destImage(BasicImageView<PixelType> & img, Point2D 
const & ul, Accessor a)
 
  557     vigra_precondition(img.isInside(ul),
 
  558                        "destImage(): ROI rectangle outside image.");
 
  559     return pair<typename BasicImageView<PixelType>::traverser,
 
  560                 Accessor>(img.upperLeft() + ul, a);
 
  563 template <
class PixelType, 
class Accessor>
 
  564 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
 
  565 maskImage(BasicImageView<PixelType> 
const & img, Accessor a)
 
  567     return pair<typename BasicImageView<PixelType>::const_traverser,
 
  568                 Accessor>(img.upperLeft(), a);
 
  571 template <
class PixelType, 
class Accessor>
 
  572 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor>
 
  573 maskImage(BasicImageView<PixelType> 
const & img, Point2D 
const & ul, Accessor a)
 
  575     vigra_precondition(img.isInside(ul),
 
  576                        "maskImage(): ROI rectangle outside image.");
 
  577     return pair<typename BasicImageView<PixelType>::const_traverser,
 
  578                 Accessor>(img.upperLeft() + ul, a);
 
  583 template <
class PixelType>
 
  584 inline triple<typename BasicImageView<PixelType>::const_traverser,
 
  585               typename BasicImageView<PixelType>::const_traverser,
 
  586               typename BasicImageView<PixelType>::ConstAccessor>
 
  587 srcImageRange(BasicImageView<PixelType> 
const & img)
 
  589     return triple<typename BasicImageView<PixelType>::const_traverser,
 
  590                   typename BasicImageView<PixelType>::const_traverser,
 
  591                   typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(),
 
  596 template <
class PixelType>
 
  597 inline triple<typename BasicImageView<PixelType>::const_traverser,
 
  598               typename BasicImageView<PixelType>::const_traverser,
 
  599               typename BasicImageView<PixelType>::ConstAccessor>
 
  600 srcImageRange(BasicImageView<PixelType> 
const & img, Rect2D 
const & roi)
 
  602     vigra_precondition(roi.left() >= 0 && roi.top() >= 0 &&
 
  603                        roi.right() <= img.width() && roi.bottom() <= img.height(),
 
  604                        "srcImageRange(): ROI rectangle outside image.");
 
  605     return triple<typename BasicImageView<PixelType>::const_traverser,
 
  606                   typename BasicImageView<PixelType>::const_traverser,
 
  607                   typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft() + roi.upperLeft(),
 
  608                                                                         img.upperLeft() + roi.lowerRight(),
 
  612 template <
class PixelType>
 
  613 inline pair< typename BasicImageView<PixelType>::const_traverser,
 
  614              typename BasicImageView<PixelType>::ConstAccessor>
 
  615 srcImage(BasicImageView<PixelType> 
const & img)
 
  617     return pair<typename BasicImageView<PixelType>::const_traverser,
 
  618                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(),
 
  622 template <
class PixelType>
 
  623 inline pair< typename BasicImageView<PixelType>::const_traverser,
 
  624              typename BasicImageView<PixelType>::ConstAccessor>
 
  625 srcImage(BasicImageView<PixelType> 
const & img, Point2D 
const & ul)
 
  627     vigra_precondition(img.isInside(ul),
 
  628                        "srcImage(): ROI rectangle outside image.");
 
  629     return pair<typename BasicImageView<PixelType>::const_traverser,
 
  630                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft() + ul,
 
  634 template <
class PixelType>
 
  635 inline triple< typename BasicImageView<PixelType>::traverser,
 
  636                typename BasicImageView<PixelType>::traverser,
 
  637                typename BasicImageView<PixelType>::Accessor>
 
  638 destImageRange(BasicImageView<PixelType> & img)
 
  640     return triple<typename BasicImageView<PixelType>::traverser,
 
  641                   typename BasicImageView<PixelType>::traverser,
 
  642                   typename BasicImageView<PixelType>::Accessor>(img.upperLeft(),
 
  647 template <
class PixelType>
 
  648 inline triple< typename BasicImageView<PixelType>::traverser,
 
  649                typename BasicImageView<PixelType>::traverser,
 
  650                typename BasicImageView<PixelType>::Accessor>
 
  651 destImageRange(BasicImageView<PixelType> & img, Rect2D 
const & roi)
 
  653     vigra_precondition(roi.left() >= 0 && roi.top() >= 0 &&
 
  654                        roi.right() <= img.width() && roi.bottom() <= img.height(),
 
  655                        "destImageRange(): ROI rectangle outside image.");
 
  656     return triple<typename BasicImageView<PixelType>::traverser,
 
  657                   typename BasicImageView<PixelType>::traverser,
 
  658                   typename BasicImageView<PixelType>::Accessor>(img.upperLeft() + roi.upperLeft(),
 
  659                                                                    img.upperLeft() + roi.lowerRight(),
 
  663 template <
class PixelType>
 
  664 inline pair< typename BasicImageView<PixelType>::traverser,
 
  665              typename BasicImageView<PixelType>::Accessor>
 
  666 destImage(BasicImageView<PixelType> & img)
 
  668     return pair<typename BasicImageView<PixelType>::traverser,
 
  669                 typename BasicImageView<PixelType>::Accessor>(img.upperLeft(),
 
  673 template <
class PixelType>
 
  674 inline pair< typename BasicImageView<PixelType>::traverser,
 
  675              typename BasicImageView<PixelType>::Accessor>
 
  676 destImage(BasicImageView<PixelType> & img, Point2D 
const & ul)
 
  678     vigra_precondition(img.isInside(ul),
 
  679                        "destImage(): ROI rectangle outside image.");
 
  680     return pair<typename BasicImageView<PixelType>::traverser,
 
  681                 typename BasicImageView<PixelType>::Accessor>(img.upperLeft() + ul,
 
  685 template <
class PixelType>
 
  686 inline pair< typename BasicImageView<PixelType>::const_traverser,
 
  687              typename BasicImageView<PixelType>::ConstAccessor>
 
  688 maskImage(BasicImageView<PixelType> 
const & img)
 
  690     return pair<typename BasicImageView<PixelType>::const_traverser,
 
  691                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(),
 
  695 template <
class PixelType>
 
  696 inline pair< typename BasicImageView<PixelType>::const_traverser,
 
  697              typename BasicImageView<PixelType>::ConstAccessor>
 
  698 maskImage(BasicImageView<PixelType> 
const & img, Point2D 
const & ul)
 
  700     vigra_precondition(img.isInside(ul),
 
  701                        "maskImage(): ROI rectangle outside image.");
 
  702     return pair<typename BasicImageView<PixelType>::const_traverser,
 
  703                 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft() + ul,
 
  708 #undef VIGRA_ASSERT_INSIDE 
IteratorTraits< traverser >::DefaultAccessor Accessor
Definition: basicimageview.hxx:169
BasicImageView(const_pointer data, std::ptrdiff_t w, std::ptrdiff_t h, std::ptrdiff_t stride=0)
Definition: basicimageview.hxx:187
reference operator[](difference_type const &d)
Definition: basicimageview.hxx:252
const_traverser upperLeft() const 
Definition: basicimageview.hxx:323
const_reference operator()(std::ptrdiff_t dx, std::ptrdiff_t dy) const 
Definition: basicimageview.hxx:279
ImageIterator< value_type > Iterator
Definition: basicimageview.hxx:132
PIXELTYPE * pointer
Definition: basicimageview.hxx:100
PIXELTYPE const & const_reference
Definition: basicimageview.hxx:96
void initImage(...)
Write a value to every pixel in an image or rectangular ROI. 
int y
Definition: diff2d.hxx:392
const_row_iterator rowEnd(std::ptrdiff_t y) const 
Definition: basicimageview.hxx:404
reference operator()(std::ptrdiff_t dx, std::ptrdiff_t dy)
Definition: basicimageview.hxx:270
const_column_iterator columnEnd(std::ptrdiff_t x) const 
Definition: basicimageview.hxx:434
row_iterator rowEnd(std::ptrdiff_t y)
Definition: basicimageview.hxx:390
PIXELTYPE & reference
Definition: basicimageview.hxx:91
int x
Definition: diff2d.hxx:385
RowIteratorSelector::res row_iterator
Definition: imageiterator.hxx:605
Two dimensional difference vector. 
Definition: diff2d.hxx:185
traverser lowerRight()
Definition: basicimageview.hxx:316
row_iterator rowBegin(std::ptrdiff_t y)
Definition: basicimageview.hxx:383
ColumnIteratorSelector::res column_iterator
Definition: imageiterator.hxx:609
Size2D size_type
Definition: basicimageview.hxx:164
PIXELTYPE * ScanOrderIterator
Definition: basicimageview.hxx:114
ImageIterator< value_type > traverser
Definition: basicimageview.hxx:128
traverser::column_iterator column_iterator
Definition: basicimageview.hxx:152
Standard 2D random access const iterator for images that store the data as a linear array...
Definition: imageiterator.hxx:893
std::ptrdiff_t height() const 
Definition: basicimageview.hxx:221
ConstImageIterator< value_type > ConstIterator
Definition: basicimageview.hxx:140
PIXELTYPE const * const_iterator
Definition: basicimageview.hxx:120
const_traverser::row_iterator const_row_iterator
Definition: basicimageview.hxx:148
Two dimensional size object. 
Definition: diff2d.hxx:482
ConstAccessor accessor() const 
Definition: basicimageview.hxx:455
const_iterator end() const 
Definition: basicimageview.hxx:373
traverser::row_iterator row_iterator
Definition: basicimageview.hxx:144
PIXELTYPE * iterator
Definition: basicimageview.hxx:110
iterator end()
Definition: basicimageview.hxx:351
pointer operator[](std::ptrdiff_t dy)
Definition: basicimageview.hxx:289
bool isInside(difference_type const &d) const 
Definition: basicimageview.hxx:243
const_reference operator[](difference_type const &d) const 
Definition: basicimageview.hxx:261
column_iterator columnEnd(std::ptrdiff_t x)
Definition: basicimageview.hxx:419
Diff2D difference_type
Definition: basicimageview.hxx:160
BasicImageView()
Definition: basicimageview.hxx:178
const_traverser::column_iterator const_column_iterator
Definition: basicimageview.hxx:156
std::ptrdiff_t width() const 
Definition: basicimageview.hxx:214
const_pointer data() const 
Definition: basicimageview.hxx:441
const_traverser lowerRight() const 
Definition: basicimageview.hxx:332
BasicImageView & init(value_type const &pixel)
Definition: basicimageview.hxx:205
BasicImage using foreign memory. 
Definition: basicimageview.hxx:76
PIXELTYPE value_type
Definition: basicimageview.hxx:82
traverser upperLeft()
Definition: basicimageview.hxx:307
column_iterator columnBegin(std::ptrdiff_t x)
Definition: basicimageview.hxx:411
iterator begin()
Definition: basicimageview.hxx:340
const_column_iterator columnBegin(std::ptrdiff_t x) const 
Definition: basicimageview.hxx:426
ConstImageIterator< value_type > const_traverser
Definition: basicimageview.hxx:136
IteratorTraits< const_traverser >::DefaultAccessor ConstAccessor
Definition: basicimageview.hxx:174
Standard 2D random access iterator for images that store the data in a linear array. 
Definition: imageiterator.hxx:848
const_iterator begin() const 
Definition: basicimageview.hxx:362
Accessor accessor()
Definition: basicimageview.hxx:448
const_row_iterator rowBegin(std::ptrdiff_t y) const 
Definition: basicimageview.hxx:397
Encapsulate access to the values an iterator points to. 
Definition: accessor.hxx:133
const_pointer operator[](std::ptrdiff_t dy) const 
Definition: basicimageview.hxx:299
size_type size() const 
Definition: basicimageview.hxx:236
PIXELTYPE const * ConstScanOrderIterator
Definition: basicimageview.hxx:124
PIXELTYPE const * const_pointer
Definition: basicimageview.hxx:104
PIXELTYPE PixelType
Definition: basicimageview.hxx:86
BasicImageView(const_pointer data, difference_type const &size, std::ptrdiff_t stride=0)
Definition: basicimageview.hxx:196
std::ptrdiff_t stride() const 
Definition: basicimageview.hxx:229