36 #ifndef VIGRA_BASICIMAGE_HXX 37 #define VIGRA_BASICIMAGE_HXX 42 #include "iteratortraits.hxx" 43 #include "accessor.hxx" 45 #include "basicimageview.hxx" 48 #ifdef VIGRA_CHECK_BOUNDS 49 #define VIGRA_ASSERT_INSIDE(diff) \ 50 vigra_precondition(this->isInside(diff), "Index out of bounds") 52 #define VIGRA_ASSERT_INSIDE(diff) 57 template <
class IMAGEITERATOR>
58 class LineBasedColumnIteratorPolicy
61 typedef IMAGEITERATOR ImageIterator;
62 typedef typename IMAGEITERATOR::LineStartIterator LineStartIterator;
63 typedef typename IMAGEITERATOR::value_type value_type;
64 typedef typename IMAGEITERATOR::difference_type::MoveY
66 typedef typename IMAGEITERATOR::reference reference;
67 typedef typename IMAGEITERATOR::index_reference index_reference;
68 typedef typename IMAGEITERATOR::pointer pointer;
69 typedef std::random_access_iterator_tag iterator_category;
74 explicit BaseType(LineStartIterator c = LineStartIterator(),
75 difference_type o = 0)
76 : line_start_(c), offset_(o)
79 LineStartIterator line_start_;
80 difference_type offset_;
83 static void initialize(BaseType &) {}
85 static reference dereference(BaseType
const & d)
86 {
return const_cast<reference
>(*(*d.line_start_ + d.offset_)); }
88 static index_reference dereference(BaseType
const & d, difference_type n)
90 return const_cast<index_reference
>(*(d.line_start_[n] + d.offset_));
93 static bool equal(BaseType
const & d1, BaseType
const & d2)
94 {
return d1.line_start_ == d2.line_start_; }
96 static bool less(BaseType
const & d1, BaseType
const & d2)
97 {
return d1.line_start_ < d2.line_start_; }
99 static difference_type difference(BaseType
const & d1, BaseType
const & d2)
100 {
return d1.line_start_ - d2.line_start_; }
102 static void increment(BaseType & d)
105 static void decrement(BaseType & d)
108 static void advance(BaseType & d, difference_type n)
109 { d.line_start_ += n; }
124 template <
class IMAGEITERATOR,
class PIXELTYPE,
125 class REFERENCE,
class POINTER,
class LINESTARTITERATOR>
130 PIXELTYPE, REFERENCE, POINTER, LINESTARTITERATOR>
self_type;
132 typedef LINESTARTITERATOR LineStartIterator;
133 typedef PIXELTYPE value_type;
134 typedef PIXELTYPE PixelType;
135 typedef REFERENCE reference;
136 typedef REFERENCE index_reference;
137 typedef POINTER pointer;
138 typedef Diff2D difference_type;
139 typedef image_traverser_tag iterator_category;
140 typedef POINTER row_iterator;
144 typedef std::ptrdiff_t MoveX;
145 typedef LINESTARTITERATOR MoveY;
150 IMAGEITERATOR &
operator+=(difference_type
const & s)
154 return static_cast<IMAGEITERATOR &
>(*this);
157 IMAGEITERATOR &
operator-=(difference_type
const & s)
161 return static_cast<IMAGEITERATOR &
>(*this);
164 IMAGEITERATOR
operator+(difference_type
const & s)
const 166 IMAGEITERATOR ret(static_cast<IMAGEITERATOR const &>(*
this));
173 IMAGEITERATOR
operator-(difference_type
const & s)
const 175 IMAGEITERATOR ret(static_cast<IMAGEITERATOR const &>(*
this));
190 return (x == rhs.x) && (y == rhs.y);
195 return (x != rhs.x) || (y != rhs.y);
198 reference operator*()
const 203 pointer operator->()
const 208 index_reference operator[](difference_type
const & d)
const 210 return *(*(y + d.
y) + x + d.
x);
213 index_reference operator()(std::ptrdiff_t dx, std::ptrdiff_t dy)
const 215 return *(*(y + dy) + x + dx);
218 pointer operator[](std::ptrdiff_t dy)
const 223 row_iterator rowIterator()
const 226 column_iterator columnIterator()
const 228 typedef typename column_iterator::BaseType Iter;
229 return column_iterator(Iter(y, x));
261 template <
class PIXELTYPE,
class ITERATOR>
264 PIXELTYPE, PIXELTYPE &, PIXELTYPE *, ITERATOR>
269 PIXELTYPE &, PIXELTYPE *, ITERATOR>
Base;
272 BasicImageIterator(ITERATOR line)
293 template <
class PIXELTYPE,
class ITERATOR>
296 PIXELTYPE, PIXELTYPE const &, PIXELTYPE const *, ITERATOR>
301 PIXELTYPE, PIXELTYPE
const &, PIXELTYPE
const *, ITERATOR>
Base;
304 ConstBasicImageIterator(ITERATOR line)
312 ConstBasicImageIterator()
316 ConstBasicImageIterator &
333 #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION 337 :
public IteratorTraitsBase<BasicImageIterator<T, T**> >
342 typedef DefaultAccessor default_accessor;
343 typedef VigraTrueType hasConstantStrides;
348 :
public IteratorTraitsBase<ConstBasicImageIterator<T, T**> >
353 typedef DefaultAccessor default_accessor;
354 typedef VigraTrueType hasConstantStrides;
357 #else // NO_PARTIAL_TEMPLATE_SPECIALIZATION 359 #define VIGRA_DEFINE_ITERATORTRAITS(VALUETYPE) \ 361 struct IteratorTraits<BasicImageIterator<VALUETYPE, VALUETYPE **> > \ 362 : public IteratorTraitsBase<BasicImageIterator<VALUETYPE, VALUETYPE **> > \ 364 typedef BasicImageIterator<VALUETYPE, VALUETYPE**> mutable_iterator; \ 365 typedef ConstBasicImageIterator<VALUETYPE, VALUETYPE**> const_iterator; \ 366 typedef typename AccessorTraits<VALUETYPE >::default_accessor DefaultAccessor; \ 367 typedef DefaultAccessor default_accessor; \ 368 typedef VigraTrueType hasConstantStrides; \ 372 struct IteratorTraits<ConstBasicImageIterator<VALUETYPE, VALUETYPE **> > \ 373 : public IteratorTraitsBase<ConstBasicImageIterator<VALUETYPE, VALUETYPE **> > \ 375 typedef BasicImageIterator<VALUETYPE, VALUETYPE**> mutable_iterator; \ 376 typedef ConstBasicImageIterator<VALUETYPE, VALUETYPE**> const_iterator; \ 377 typedef typename AccessorTraits<VALUETYPE >::default_const_accessor DefaultAccessor; \ 378 typedef DefaultAccessor default_accessor; \ 379 typedef VigraTrueType hasConstantStrides; \ 390 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 2> 391 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
392 #undef VIGRA_PIXELTYPE 393 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 3> 394 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
395 #undef VIGRA_PIXELTYPE 396 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 4> 397 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
398 #undef VIGRA_PIXELTYPE 399 #define VIGRA_PIXELTYPE TinyVector<short, 2> 400 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
401 #undef VIGRA_PIXELTYPE 402 #define VIGRA_PIXELTYPE TinyVector<short, 3> 403 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
404 #undef VIGRA_PIXELTYPE 405 #define VIGRA_PIXELTYPE TinyVector<short, 4> 406 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
407 #undef VIGRA_PIXELTYPE 408 #define VIGRA_PIXELTYPE TinyVector<unsigned short, 2> 409 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
410 #undef VIGRA_PIXELTYPE 411 #define VIGRA_PIXELTYPE TinyVector<unsigned short, 3> 412 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
413 #undef VIGRA_PIXELTYPE 414 #define VIGRA_PIXELTYPE TinyVector<unsigned short, 4> 415 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
416 #undef VIGRA_PIXELTYPE 417 #define VIGRA_PIXELTYPE TinyVector<int, 2> 418 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
419 #undef VIGRA_PIXELTYPE 420 #define VIGRA_PIXELTYPE TinyVector<int, 3> 421 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
422 #undef VIGRA_PIXELTYPE 423 #define VIGRA_PIXELTYPE TinyVector<int, 4> 424 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
425 #undef VIGRA_PIXELTYPE 426 #define VIGRA_PIXELTYPE TinyVector<unsigned int, 2> 427 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
428 #undef VIGRA_PIXELTYPE 429 #define VIGRA_PIXELTYPE TinyVector<unsigned int, 3> 430 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
431 #undef VIGRA_PIXELTYPE 432 #define VIGRA_PIXELTYPE TinyVector<unsigned int, 4> 433 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
434 #undef VIGRA_PIXELTYPE 435 #define VIGRA_PIXELTYPE TinyVector<float, 2> 436 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
437 #undef VIGRA_PIXELTYPE 438 #define VIGRA_PIXELTYPE TinyVector<float, 3> 439 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
440 #undef VIGRA_PIXELTYPE 441 #define VIGRA_PIXELTYPE TinyVector<float, 4> 442 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
443 #undef VIGRA_PIXELTYPE 444 #define VIGRA_PIXELTYPE TinyVector<double, 2> 445 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
446 #undef VIGRA_PIXELTYPE 447 #define VIGRA_PIXELTYPE TinyVector<double, 3> 448 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
449 #undef VIGRA_PIXELTYPE 450 #define VIGRA_PIXELTYPE TinyVector<double, 4> 451 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
452 #undef VIGRA_PIXELTYPE 454 #undef VIGRA_DEFINE_ITERATORTRAITS 456 #endif // NO_PARTIAL_TEMPLATE_SPECIALIZATION 472 template <
class PIXELTYPE,
class Alloc = std::allocator<PIXELTYPE> >
582 typedef Alloc Allocator;
583 typedef typename Alloc::template rebind<PIXELTYPE *>::other LineAllocator;
605 BasicImage(std::ptrdiff_t width, std::ptrdiff_t height, Alloc
const & alloc = Alloc())
612 vigra_precondition((width >= 0) && (height >= 0),
613 "BasicImage::BasicImage(int width, int height): " 614 "width and height must be >= 0.\n");
616 resize(width, height, value_type());
621 explicit BasicImage(difference_type
const & size, Alloc
const & alloc = Alloc())
628 vigra_precondition((size.
x >= 0) && (size.
y >= 0),
629 "BasicImage::BasicImage(Diff2D size): " 630 "size.x and size.y must be >= 0.\n");
632 resize(size.
x, size.
y, value_type());
640 BasicImage(std::ptrdiff_t width, std::ptrdiff_t height, value_type
const & d, Alloc
const & alloc = Alloc())
647 vigra_precondition((width >= 0) && (height >= 0),
648 "BasicImage::BasicImage(int width, int height, value_type const & ): " 649 "width and height must be >= 0.\n");
651 resize(width, height, d);
658 BasicImage(std::ptrdiff_t width, std::ptrdiff_t height, SkipInitializationTag, Alloc
const & alloc = Alloc())
665 vigra_precondition((width >= 0) && (height >= 0),
666 "BasicImage::BasicImage(int width, int height, value_type const & ): " 667 "width and height must be >= 0.\n");
669 resize(width, height, SkipInitialization);
676 explicit BasicImage(difference_type
const & size, value_type
const & d, Alloc
const & alloc = Alloc())
683 vigra_precondition((size.
x >= 0) && (size.
y >= 0),
684 "BasicImage::BasicImage(Diff2D const & size, value_type const & v): " 685 "size.x and size.y must be >= 0.\n");
687 resize(size.
x, size.
y, d);
693 explicit BasicImage(difference_type
const & size, SkipInitializationTag, Alloc
const & alloc = Alloc())
700 vigra_precondition((size.
x >= 0) && (size.
y >= 0),
701 "BasicImage::BasicImage(Diff2D const & size, value_type const & v): " 702 "size.x and size.y must be >= 0.\n");
704 resize(size.
x, size.
y, SkipInitialization);
711 BasicImage(std::ptrdiff_t width, std::ptrdiff_t height, const_pointer d, Alloc
const & alloc = Alloc())
718 vigra_precondition((width >= 0) && (height >= 0),
719 "BasicImage::BasicImage(int width, int height, const_pointer ): " 720 "width and height must be >= 0.\n");
722 resizeCopy(width, height, d);
728 explicit BasicImage(difference_type
const & size, const_pointer d, Alloc
const & alloc = Alloc())
735 vigra_precondition((size.
x >= 0) && (size.
y >= 0),
736 "BasicImage::BasicImage(Diff2D const & size, const_pointer): " 737 "size.x and size.y must be >= 0.\n");
739 resizeCopy(size.
x, size.
y, d);
748 allocator_(rhs.allocator_),
749 pallocator_(rhs.pallocator_)
776 void resize(std::ptrdiff_t width, std::ptrdiff_t height)
778 if(width != width_ || height != height_)
779 resize(width, height, value_type());
785 void resize(difference_type
const & size)
787 if(size.
x != width_ || size.
y != height_)
789 resize(size.
x, size.
y, value_type());
798 void resize(std::ptrdiff_t width, std::ptrdiff_t height, value_type
const & d)
800 resizeImpl(width, height, d,
false);
814 void resize(std::ptrdiff_t width, std::ptrdiff_t height, SkipInitializationTag)
816 resizeImpl(width, height, NumericTraits<value_type>::zero(),
817 CanSkipInitialization<value_type>::value);
823 void resizeCopy(std::ptrdiff_t width, std::ptrdiff_t height, const_pointer data);
854 return size_type(width(), height());
861 return d.
x >= 0 && d.
y >= 0 &&
862 d.
x < width() && d.
y < height();
870 VIGRA_ASSERT_INSIDE(d);
871 return lines_[d.
y][d.
x];
879 VIGRA_ASSERT_INSIDE(d);
880 return lines_[d.
y][d.
x];
888 VIGRA_ASSERT_INSIDE(difference_type(dx,dy));
889 return lines_[dy][dx];
895 const_reference
operator()(std::ptrdiff_t dx, std::ptrdiff_t dy)
const 897 VIGRA_ASSERT_INSIDE(difference_type(dx,dy));
898 return lines_[dy][dx];
907 VIGRA_ASSERT_INSIDE(difference_type(0,dy));
917 VIGRA_ASSERT_INSIDE(difference_type(0,dy));
925 vigra_precondition(data_ != 0,
926 "BasicImage::upperLeft(): image must have non-zero size.");
927 return traverser(lines_);
936 vigra_precondition(data_ != 0,
937 "BasicImage::lowerRight(): image must have non-zero size.");
938 return upperLeft() + size();
945 vigra_precondition(data_ != 0,
946 "BasicImage::upperLeft(): image must have non-zero size.");
956 vigra_precondition(data_ != 0,
957 "BasicImage::lowerRight(): image must have non-zero size.");
958 return upperLeft() + size();
965 vigra_precondition(data_ != 0,
966 "BasicImage::begin(): image must have non-zero size.");
974 vigra_precondition(data_ != 0,
975 "BasicImage::end(): image must have non-zero size.");
976 return data_ + width() * height();
983 vigra_precondition(data_ != 0,
984 "BasicImage::begin(): image must have non-zero size.");
990 const_iterator
end()
const 992 vigra_precondition(data_ != 0,
993 "BasicImage::end(): image must have non-zero size.");
994 return data_ + width() * height();
1008 return rowBegin(y) + width();
1020 const_row_iterator
rowEnd(std::ptrdiff_t y)
const 1022 return rowBegin(y) + width();
1029 typedef typename column_iterator::BaseType Iter;
1030 return column_iterator(Iter(lines_, x));
1037 return columnBegin(x) + height();
1044 typedef typename const_column_iterator::BaseType Iter;
1045 return const_column_iterator(Iter(lines_, x));
1052 return columnBegin(x) + height();
1073 return ConstAccessor();
1079 void resizeImpl(std::ptrdiff_t width, std::ptrdiff_t height, value_type
const & d,
bool skipInit);
1082 value_type ** initLineStartArray(value_type * data, std::ptrdiff_t width, std::ptrdiff_t height);
1085 PIXELTYPE ** lines_;
1086 std::ptrdiff_t width_, height_;
1088 LineAllocator pallocator_;
1091 template <
class PIXELTYPE,
class Alloc>
1097 if((width() != rhs.
width()) ||
1098 (height() != rhs.
height()))
1104 ConstScanOrderIterator is = rhs.
begin();
1105 ConstScanOrderIterator iend = rhs.
end();
1106 ScanOrderIterator
id = begin();
1108 for(; is != iend; ++is, ++id) *
id = *is;
1114 template <
class PIXELTYPE,
class Alloc>
1118 ScanOrderIterator i = begin();
1119 ScanOrderIterator iend = end();
1121 for(; i != iend; ++i) *i = pixel;
1126 template <
class PIXELTYPE,
class Alloc>
1130 ScanOrderIterator i = begin();
1131 ScanOrderIterator iend = end();
1133 for(; i != iend; ++i) *i = pixel;
1138 template <
class PIXELTYPE,
class Alloc>
1142 vigra_precondition((width >= 0) && (height >= 0),
1143 "BasicImage::resize(int width, int height, value_type const &): " 1144 "width and height must be >= 0.\n");
1145 vigra_precondition(width * height >= 0,
1146 "BasicImage::resize(int width, int height, value_type const &): " 1147 "width * height too large (integer overflow -> negative).\n");
1149 if (width_ != width || height_ != height)
1151 value_type * newdata = 0;
1152 value_type ** newlines = 0;
1153 if(width*height > 0)
1155 if (width*height != width_*height_)
1157 newdata = allocator_.allocate(
typename Alloc::size_type(width*height));
1159 std::uninitialized_fill_n(newdata, width*height, d);
1160 newlines = initLineStartArray(newdata, width, height);
1167 std::fill_n(newdata, width*height, d);
1168 newlines = initLineStartArray(newdata, width, height);
1169 pallocator_.deallocate(lines_,
typename Alloc::size_type(height_));
1182 else if(width*height > 0 && !skipInit)
1184 std::fill_n(data_, width*height, d);
1189 template <
class PIXELTYPE,
class Alloc>
1193 std::ptrdiff_t newsize = width*height;
1194 if (width_ != width || height_ != height)
1196 value_type * newdata = 0;
1197 value_type ** newlines = 0;
1200 if (newsize != width_*height_)
1202 newdata = allocator_.allocate(
typename Alloc::size_type(newsize));
1203 std::uninitialized_copy(data, data + newsize, newdata);
1204 newlines = initLineStartArray(newdata, width, height);
1210 std::copy(data, data + newsize, newdata);
1211 newlines = initLineStartArray(newdata, width, height);
1212 pallocator_.deallocate(lines_,
typename Alloc::size_type(height_));
1225 else if(newsize > 0)
1227 std::copy(data, data + newsize, data_);
1231 template <
class PIXELTYPE,
class Alloc>
1237 std::swap( data_, rhs.data_ );
1238 std::swap( lines_, rhs.lines_ );
1239 std::swap( width_, rhs.width_ );
1240 std::swap( height_, rhs.height_ );
1244 template <
class PIXELTYPE,
class Alloc>
1250 ScanOrderIterator i = begin();
1251 ScanOrderIterator iend = end();
1253 for(; i != iend; ++i) (*i).~PIXELTYPE();
1255 allocator_.deallocate(data_,
typename Alloc::size_type(width()*height()));
1256 pallocator_.deallocate(lines_,
typename Alloc::size_type(height_));
1260 template <
class PIXELTYPE,
class Alloc>
1264 value_type ** lines = pallocator_.allocate(
typename Alloc::size_type(height));
1265 for(std::ptrdiff_t y=0; y<height; ++y)
1266 lines[y] = data + y*width;
1276 template <
class PixelType,
class Accessor,
class Alloc>
1277 inline triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1281 return triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1282 typename BasicImage<PixelType, Alloc>::const_traverser,
1288 template <
class PixelType,
class Accessor,
class Alloc>
1289 inline triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1290 typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1293 vigra_precondition(roi.
left() >= 0 && roi.
top() >= 0 &&
1295 "srcImageRange(): ROI rectangle outside image.");
1296 return triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1297 typename BasicImage<PixelType, Alloc>::const_traverser,
1303 template <
class PixelType,
class Accessor,
class Alloc>
1304 inline pair<typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1307 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1311 template <
class PixelType,
class Accessor,
class Alloc>
1312 inline pair<typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1315 vigra_precondition(img.
isInside(ul),
1316 "srcImage(): ROI rectangle outside image.");
1317 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1321 template <
class PixelType,
class Accessor,
class Alloc>
1322 inline triple<typename BasicImage<PixelType, Alloc>::traverser,
1326 return triple<typename BasicImage<PixelType, Alloc>::traverser,
1327 typename BasicImage<PixelType, Alloc>::traverser,
1333 template <
class PixelType,
class Accessor,
class Alloc>
1334 inline triple<typename BasicImage<PixelType, Alloc>::traverser,
1335 typename BasicImage<PixelType, Alloc>::traverser, Accessor>
1338 vigra_precondition(roi.
left() >= 0 && roi.
top() >= 0 &&
1340 "destImageRange(): ROI rectangle outside image.");
1341 return triple<typename BasicImage<PixelType, Alloc>::traverser,
1342 typename BasicImage<PixelType, Alloc>::traverser,
1348 template <
class PixelType,
class Accessor,
class Alloc>
1349 inline pair<typename BasicImage<PixelType, Alloc>::traverser, Accessor>
1352 return pair<typename BasicImage<PixelType, Alloc>::traverser,
1356 template <
class PixelType,
class Accessor,
class Alloc>
1357 inline pair<typename BasicImage<PixelType, Alloc>::traverser, Accessor>
1360 vigra_precondition(img.
isInside(ul),
1361 "destImage(): ROI rectangle outside image.");
1362 return pair<typename BasicImage<PixelType, Alloc>::traverser,
1366 template <
class PixelType,
class Accessor,
class Alloc>
1367 inline pair<typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1370 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1374 template <
class PixelType,
class Accessor,
class Alloc>
1375 inline pair<typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1378 vigra_precondition(img.
isInside(ul),
1379 "maskImage(): ROI rectangle outside image.");
1380 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1386 template <
class PixelType,
class Alloc>
1387 inline triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1388 typename BasicImage<PixelType, Alloc>::const_traverser,
1392 return triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1393 typename BasicImage<PixelType, Alloc>::const_traverser,
1399 template <
class PixelType,
class Alloc>
1400 inline triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1401 typename BasicImage<PixelType, Alloc>::const_traverser,
1405 vigra_precondition(roi.
left() >= 0 && roi.
top() >= 0 &&
1407 "srcImageRange(): ROI rectangle outside image.");
1408 return triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1409 typename BasicImage<PixelType, Alloc>::const_traverser,
1415 template <
class PixelType,
class Alloc>
1416 inline pair< typename BasicImage<PixelType, Alloc>::const_traverser,
1420 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1425 template <
class PixelType,
class Alloc>
1426 inline pair< typename BasicImage<PixelType, Alloc>::const_traverser,
1430 vigra_precondition(img.
isInside(ul),
1431 "srcImage(): ROI rectangle outside image.");
1432 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1437 template <
class PixelType,
class Alloc>
1438 inline triple< typename BasicImage<PixelType, Alloc>::traverser,
1439 typename BasicImage<PixelType, Alloc>::traverser,
1443 return triple<typename BasicImage<PixelType, Alloc>::traverser,
1444 typename BasicImage<PixelType, Alloc>::traverser,
1450 template <
class PixelType,
class Alloc>
1451 inline triple< typename BasicImage<PixelType, Alloc>::traverser,
1452 typename BasicImage<PixelType, Alloc>::traverser,
1456 vigra_precondition(roi.
left() >= 0 && roi.
top() >= 0 &&
1458 "destImageRange(): ROI rectangle outside image.");
1459 return triple<typename BasicImage<PixelType, Alloc>::traverser,
1460 typename BasicImage<PixelType, Alloc>::traverser,
1466 template <
class PixelType,
class Alloc>
1467 inline pair< typename BasicImage<PixelType, Alloc>::traverser,
1471 return pair<typename BasicImage<PixelType, Alloc>::traverser,
1476 template <
class PixelType,
class Alloc>
1477 inline pair< typename BasicImage<PixelType, Alloc>::traverser,
1481 vigra_precondition(img.
isInside(ul),
1482 "destImage(): ROI rectangle outside image.");
1483 return pair<typename BasicImage<PixelType, Alloc>::traverser,
1488 template <
class PixelType,
class Alloc>
1489 inline pair< typename BasicImage<PixelType, Alloc>::const_traverser,
1493 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1498 template <
class PixelType,
class Alloc>
1499 inline pair< typename BasicImage<PixelType, Alloc>::const_traverser,
1503 vigra_precondition(img.
isInside(ul),
1504 "maskImage(): ROI rectangle outside image.");
1505 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1511 #undef VIGRA_ASSERT_INSIDE 1512 #endif // VIGRA_BASICIMAGE_HXX iterator end()
Definition: basicimage.hxx:972
iterator begin()
Definition: basicimage.hxx:963
int MoveY
Definition: diff2d.hxx:229
ConstBasicImageIterator< PIXELTYPE, PIXELTYPE ** > ConstIterator
Definition: basicimage.hxx:542
int right() const
Definition: diff2d.hxx:989
size_type size() const
Definition: basicimage.hxx:852
const_traverser::column_iterator const_column_iterator
Definition: basicimage.hxx:558
Export associated information for each image iterator.
Definition: iteratortraits.hxx:109
row_iterator rowEnd(std::ptrdiff_t y)
Definition: basicimage.hxx:1006
Accessor accessor()
Definition: basicimage.hxx:1064
PIXELTYPE & reference
Definition: basicimage.hxx:488
int y
Definition: diff2d.hxx:392
Diff2D operator-(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:711
BasicImage(difference_type const &size, SkipInitializationTag, Alloc const &alloc=Alloc())
Definition: basicimage.hxx:693
IteratorTraits< traverser >::DefaultAccessor Accessor
Definition: basicimage.hxx:571
BasicImage(std::ptrdiff_t width, std::ptrdiff_t height, value_type const &d, Alloc const &alloc=Alloc())
Definition: basicimage.hxx:640
const_row_iterator rowEnd(std::ptrdiff_t y) const
Definition: basicimage.hxx:1020
const_pointer operator[](std::ptrdiff_t dy) const
Definition: basicimage.hxx:915
BasicImage & init(value_type const &pixel)
Definition: basicimage.hxx:1128
int bottom() const
Definition: diff2d.hxx:997
int x
Definition: diff2d.hxx:385
Point2D const & upperLeft() const
Definition: diff2d.hxx:911
PIXELTYPE const & const_reference
Definition: basicimage.hxx:494
BasicImage(difference_type const &size, const_pointer d, Alloc const &alloc=Alloc())
Definition: basicimage.hxx:728
column_iterator columnEnd(std::ptrdiff_t x)
Definition: basicimage.hxx:1035
Diff2D operator+(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:739
BasicImage()
Definition: basicimage.hxx:587
Two dimensional difference vector.
Definition: diff2d.hxx:185
const_row_iterator rowBegin(std::ptrdiff_t y) const
Definition: basicimage.hxx:1013
void resize(std::ptrdiff_t width, std::ptrdiff_t height, SkipInitializationTag)
Definition: basicimage.hxx:814
PIXELTYPE * pointer
Definition: basicimage.hxx:498
traverser::column_iterator column_iterator
Definition: basicimage.hxx:554
PIXELTYPE const * ConstScanOrderIterator
Definition: basicimage.hxx:522
std::ptrdiff_t width() const
Definition: basicimage.hxx:838
Definition: accessor.hxx:43
int left() const
Definition: diff2d.hxx:974
FFTWComplex< R > & operator-=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
subtract-assignment
Definition: fftw3.hxx:867
BasicImageIterator< PIXELTYPE, PIXELTYPE ** > traverser
Definition: basicimage.hxx:526
Two dimensional size object.
Definition: diff2d.hxx:482
BasicImage(std::ptrdiff_t width, std::ptrdiff_t height, SkipInitializationTag, Alloc const &alloc=Alloc())
Definition: basicimage.hxx:658
Two dimensional point or position.
Definition: diff2d.hxx:592
BasicImage(const BasicImage &rhs)
Definition: basicimage.hxx:744
std::ptrdiff_t height() const
Definition: basicimage.hxx:845
Definition: basicimage.hxx:262
column_iterator columnBegin(std::ptrdiff_t x)
Definition: basicimage.hxx:1027
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment
Definition: fftw3.hxx:859
BasicImageIterator< PIXELTYPE, PIXELTYPE ** > Iterator
Definition: basicimage.hxx:530
BasicImage(std::ptrdiff_t width, std::ptrdiff_t height, Alloc const &alloc=Alloc())
Definition: basicimage.hxx:605
PIXELTYPE const * const_pointer
Definition: basicimage.hxx:502
void swap(BasicImage &rhs)
Definition: basicimage.hxx:1233
const_column_iterator columnBegin(std::ptrdiff_t x) const
Definition: basicimage.hxx:1042
Alloc allocator_type
Definition: basicimage.hxx:580
int top() const
Definition: diff2d.hxx:981
bool operator!=(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
not equal
Definition: fftw3.hxx:841
const_column_iterator columnEnd(std::ptrdiff_t x) const
Definition: basicimage.hxx:1050
Definition: basicimage.hxx:126
bool isInside(difference_type const &d) const
Definition: basicimage.hxx:859
BasicImage(difference_type const &size, value_type const &d, Alloc const &alloc=Alloc())
Definition: basicimage.hxx:676
int MoveX
Definition: diff2d.hxx:226
bool operator==(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
equal
Definition: fftw3.hxx:825
ConstAccessor accessor() const
Definition: basicimage.hxx:1071
const_traverser upperLeft() const
Definition: basicimage.hxx:943
const_reference operator()(std::ptrdiff_t dx, std::ptrdiff_t dy) const
Definition: basicimage.hxx:895
reference operator()(std::ptrdiff_t dx, std::ptrdiff_t dy)
Definition: basicimage.hxx:886
pointer operator[](std::ptrdiff_t dy)
Definition: basicimage.hxx:905
const_traverser::row_iterator const_row_iterator
Definition: basicimage.hxx:550
PIXELTYPE const * const_iterator
Definition: basicimage.hxx:518
Size2D size_type
Definition: basicimage.hxx:566
IteratorTraits< const_traverser >::DefaultAccessor ConstAccessor
Definition: basicimage.hxx:576
const_iterator begin() const
Definition: basicimage.hxx:981
void resize(std::ptrdiff_t width, std::ptrdiff_t height, value_type const &d)
Definition: basicimage.hxx:798
traverser lowerRight()
Definition: basicimage.hxx:934
PIXELTYPE PixelType
Definition: basicimage.hxx:483
ConstBasicImageIterator< PIXELTYPE, PIXELTYPE ** > const_traverser
Definition: basicimage.hxx:536
BasicImage(difference_type const &size, Alloc const &alloc=Alloc())
Definition: basicimage.hxx:621
Fundamental class template for images.
Definition: basicimage.hxx:473
PIXELTYPE * ScanOrderIterator
Definition: basicimage.hxx:512
BasicImage(std::ptrdiff_t width, std::ptrdiff_t height, const_pointer d, Alloc const &alloc=Alloc())
Definition: basicimage.hxx:711
const_pointer data() const
Definition: basicimage.hxx:1057
const_iterator end() const
Definition: basicimage.hxx:990
Point2D const & lowerRight() const
Definition: diff2d.hxx:919
Two dimensional rectangle.
Definition: diff2d.hxx:872
Definition: basicimage.hxx:294
Encapsulate read access to the values an iterator points to.
Definition: accessor.hxx:269
void resize(std::ptrdiff_t width, std::ptrdiff_t height)
Definition: basicimage.hxx:776
void resizeCopy(std::ptrdiff_t width, std::ptrdiff_t height, const_pointer data)
Definition: basicimage.hxx:1191
const_traverser lowerRight() const
Definition: basicimage.hxx:954
row_iterator rowBegin(std::ptrdiff_t y)
Definition: basicimage.hxx:999
traverser::row_iterator row_iterator
Definition: basicimage.hxx:546
reference operator[](difference_type const &d)
Definition: basicimage.hxx:868
~BasicImage()
Definition: basicimage.hxx:756
void resizeCopy(const BasicImage &rhs)
Definition: basicimage.hxx:827
Diff2D difference_type
Definition: basicimage.hxx:562
Class for a single RGB value.
Definition: accessor.hxx:938
Encapsulate access to the values an iterator points to.
Definition: accessor.hxx:133
Quickly create 1-dimensional iterator adapters.
Definition: iteratoradapter.hxx:147
const_reference operator[](difference_type const &d) const
Definition: basicimage.hxx:877
BasicImage & operator=(const BasicImage &rhs)
Definition: basicimage.hxx:1093
void resize(difference_type const &size)
Definition: basicimage.hxx:785
BasicImage(Alloc const &alloc)
Definition: basicimage.hxx:595
PIXELTYPE value_type
Definition: basicimage.hxx:479
traverser upperLeft()
Definition: basicimage.hxx:923
PIXELTYPE * iterator
Definition: basicimage.hxx:508