36 #ifndef VIGRA_BASICIMAGE_HXX
37 #define VIGRA_BASICIMAGE_HXX
41 #include "utilities.hxx"
42 #include "iteratortraits.hxx"
43 #include "accessor.hxx"
47 #ifdef VIGRA_CHECK_BOUNDS
48 #define VIGRA_ASSERT_INSIDE(diff) \
49 vigra_precondition(this->isInside(diff), "Index out of bounds")
51 #define VIGRA_ASSERT_INSIDE(diff)
56 template <
class IMAGEITERATOR>
57 class LineBasedColumnIteratorPolicy
60 typedef IMAGEITERATOR ImageIterator;
61 typedef typename IMAGEITERATOR::LineStartIterator LineStartIterator;
62 typedef typename IMAGEITERATOR::value_type value_type;
63 typedef typename IMAGEITERATOR::difference_type::MoveY
65 typedef typename IMAGEITERATOR::reference reference;
66 typedef typename IMAGEITERATOR::index_reference index_reference;
67 typedef typename IMAGEITERATOR::pointer pointer;
68 typedef std::random_access_iterator_tag iterator_category;
73 explicit BaseType(LineStartIterator c = LineStartIterator(),
74 difference_type o = 0)
75 : line_start_(c), offset_(o)
78 LineStartIterator line_start_;
79 difference_type offset_;
82 static void initialize(BaseType &) {}
84 static reference dereference(BaseType
const & d)
85 {
return const_cast<reference
>(*(*d.line_start_ + d.offset_)); }
87 static index_reference dereference(BaseType
const & d, difference_type n)
89 return const_cast<index_reference
>(*(d.line_start_[n] + d.offset_));
92 static bool equal(BaseType
const & d1, BaseType
const & d2)
93 {
return d1.line_start_ == d2.line_start_; }
95 static bool less(BaseType
const & d1, BaseType
const & d2)
96 {
return d1.line_start_ < d2.line_start_; }
98 static difference_type difference(BaseType
const & d1, BaseType
const & d2)
99 {
return d1.line_start_ - d2.line_start_; }
101 static void increment(BaseType & d)
104 static void decrement(BaseType & d)
107 static void advance(BaseType & d, difference_type n)
108 { d.line_start_ += n; }
123 template <
class IMAGEITERATOR,
class PIXELTYPE,
124 class REFERENCE,
class POINTER,
class LINESTARTITERATOR>
129 PIXELTYPE, REFERENCE, POINTER, LINESTARTITERATOR>
self_type;
131 typedef LINESTARTITERATOR LineStartIterator;
132 typedef PIXELTYPE value_type;
133 typedef PIXELTYPE PixelType;
134 typedef REFERENCE reference;
135 typedef REFERENCE index_reference;
136 typedef POINTER pointer;
138 typedef image_traverser_tag iterator_category;
139 typedef POINTER row_iterator;
144 typedef LINESTARTITERATOR MoveY;
153 return static_cast<IMAGEITERATOR &
>(*this);
160 return static_cast<IMAGEITERATOR &
>(*this);
165 IMAGEITERATOR ret(static_cast<IMAGEITERATOR const &>(*
this));
174 IMAGEITERATOR ret(static_cast<IMAGEITERATOR const &>(*
this));
189 return (x == rhs.x) && (y == rhs.y);
194 return (x != rhs.x) || (y != rhs.y);
197 reference operator*()
const
202 pointer operator->()
const
209 return *(*(y + d.
y) + x + d.
x);
212 index_reference operator()(
int dx,
int dy)
const
214 return *(*(y + dy) + x + dx);
217 pointer operator[](
int dy)
const
222 row_iterator rowIterator()
const
227 typedef typename column_iterator::BaseType Iter;
260 template <
class PIXELTYPE,
class ITERATOR>
263 PIXELTYPE, PIXELTYPE &, PIXELTYPE *, ITERATOR>
268 PIXELTYPE &, PIXELTYPE *, ITERATOR>
Base;
292 template <
class PIXELTYPE,
class ITERATOR>
295 PIXELTYPE, PIXELTYPE const &, PIXELTYPE const *, ITERATOR>
300 PIXELTYPE, PIXELTYPE
const &, PIXELTYPE
const *, ITERATOR>
Base;
332 #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
336 :
public IteratorTraitsBase<BasicImageIterator<T, T**> >
341 typedef DefaultAccessor default_accessor;
342 typedef VigraTrueType hasConstantStrides;
346 struct IteratorTraits<ConstBasicImageIterator<T, T**> >
347 :
public IteratorTraitsBase<ConstBasicImageIterator<T, T**> >
349 typedef BasicImageIterator<T, T**> mutable_iterator;
350 typedef ConstBasicImageIterator<T, T**> const_iterator;
351 typedef typename AccessorTraits<T>::default_const_accessor DefaultAccessor;
352 typedef DefaultAccessor default_accessor;
353 typedef VigraTrueType hasConstantStrides;
356 #else // NO_PARTIAL_TEMPLATE_SPECIALIZATION
358 #define VIGRA_DEFINE_ITERATORTRAITS(VALUETYPE) \
360 struct IteratorTraits<BasicImageIterator<VALUETYPE, VALUETYPE **> > \
361 : public IteratorTraitsBase<BasicImageIterator<VALUETYPE, VALUETYPE **> > \
363 typedef BasicImageIterator<VALUETYPE, VALUETYPE**> mutable_iterator; \
364 typedef ConstBasicImageIterator<VALUETYPE, VALUETYPE**> const_iterator; \
365 typedef typename AccessorTraits<VALUETYPE >::default_accessor DefaultAccessor; \
366 typedef DefaultAccessor default_accessor; \
367 typedef VigraTrueType hasConstantStrides; \
371 struct IteratorTraits<ConstBasicImageIterator<VALUETYPE, VALUETYPE **> > \
372 : public IteratorTraitsBase<ConstBasicImageIterator<VALUETYPE, VALUETYPE **> > \
374 typedef BasicImageIterator<VALUETYPE, VALUETYPE**> mutable_iterator; \
375 typedef ConstBasicImageIterator<VALUETYPE, VALUETYPE**> const_iterator; \
376 typedef typename AccessorTraits<VALUETYPE >::default_const_accessor DefaultAccessor; \
377 typedef DefaultAccessor default_accessor; \
378 typedef VigraTrueType hasConstantStrides; \
381 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<unsigned char>)
382 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
short>)
383 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
unsigned short>)
384 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
int>)
385 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
unsigned int>)
386 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
float>)
387 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<
double>)
389 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 2>
390 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
391 #undef VIGRA_PIXELTYPE
392 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 3>
393 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
394 #undef VIGRA_PIXELTYPE
395 #define VIGRA_PIXELTYPE TinyVector<unsigned char, 4>
396 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
397 #undef VIGRA_PIXELTYPE
398 #define VIGRA_PIXELTYPE TinyVector<short, 2>
399 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
400 #undef VIGRA_PIXELTYPE
401 #define VIGRA_PIXELTYPE TinyVector<short, 3>
402 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
403 #undef VIGRA_PIXELTYPE
404 #define VIGRA_PIXELTYPE TinyVector<short, 4>
405 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
406 #undef VIGRA_PIXELTYPE
407 #define VIGRA_PIXELTYPE TinyVector<unsigned short, 2>
408 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
409 #undef VIGRA_PIXELTYPE
410 #define VIGRA_PIXELTYPE TinyVector<unsigned short, 3>
411 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
412 #undef VIGRA_PIXELTYPE
413 #define VIGRA_PIXELTYPE TinyVector<unsigned short, 4>
414 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
415 #undef VIGRA_PIXELTYPE
416 #define VIGRA_PIXELTYPE TinyVector<int, 2>
417 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
418 #undef VIGRA_PIXELTYPE
419 #define VIGRA_PIXELTYPE TinyVector<int, 3>
420 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
421 #undef VIGRA_PIXELTYPE
422 #define VIGRA_PIXELTYPE TinyVector<int, 4>
423 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
424 #undef VIGRA_PIXELTYPE
425 #define VIGRA_PIXELTYPE TinyVector<unsigned int, 2>
426 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
427 #undef VIGRA_PIXELTYPE
428 #define VIGRA_PIXELTYPE TinyVector<unsigned int, 3>
429 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
430 #undef VIGRA_PIXELTYPE
431 #define VIGRA_PIXELTYPE TinyVector<unsigned int, 4>
432 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
433 #undef VIGRA_PIXELTYPE
434 #define VIGRA_PIXELTYPE TinyVector<float, 2>
435 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
436 #undef VIGRA_PIXELTYPE
437 #define VIGRA_PIXELTYPE TinyVector<float, 3>
438 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
439 #undef VIGRA_PIXELTYPE
440 #define VIGRA_PIXELTYPE TinyVector<float, 4>
441 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
442 #undef VIGRA_PIXELTYPE
443 #define VIGRA_PIXELTYPE TinyVector<double, 2>
444 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
445 #undef VIGRA_PIXELTYPE
446 #define VIGRA_PIXELTYPE TinyVector<double, 3>
447 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
448 #undef VIGRA_PIXELTYPE
449 #define VIGRA_PIXELTYPE TinyVector<double, 4>
450 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE)
451 #undef VIGRA_PIXELTYPE
453 #undef VIGRA_DEFINE_ITERATORTRAITS
455 #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;
612 vigra_precondition((width >= 0) && (height >= 0),
613 "BasicImage::BasicImage(int width, int height): "
614 "width and height must be >= 0.\n");
628 vigra_precondition((size.
x >= 0) && (size.
y >= 0),
629 "BasicImage::BasicImage(Diff2D size): "
630 "size.x and size.y must be >= 0.\n");
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");
658 BasicImage(
int width,
int 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);
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");
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);
718 vigra_precondition((width >= 0) && (height >= 0),
719 "BasicImage::BasicImage(int width, int height, const_pointer ): "
720 "width and height must be >= 0.\n");
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");
748 allocator_(rhs.allocator_),
749 pallocator_(rhs.pallocator_)
778 if(width != width_ || height != height_)
787 if(size.
x != width_ || size.
y != height_)
800 resizeImpl(width, height, d,
false);
814 void resize(
int width,
int height, SkipInitializationTag)
816 resizeImpl(width, height, NumericTraits<value_type>::zero(),
817 CanSkipInitialization<value_type>::value);
861 return d.
x >= 0 && d.
y >= 0 &&
870 VIGRA_ASSERT_INSIDE(d);
871 return lines_[d.
y][d.
x];
879 VIGRA_ASSERT_INSIDE(d);
880 return lines_[d.
y][d.
x];
889 return lines_[dy][dx];
898 return lines_[dy][dx];
925 vigra_precondition(data_ != 0,
926 "BasicImage::upperLeft(): image must have non-zero size.");
936 vigra_precondition(data_ != 0,
937 "BasicImage::lowerRight(): image must have non-zero 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.");
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.");
983 vigra_precondition(data_ != 0,
984 "BasicImage::begin(): image must have non-zero size.");
992 vigra_precondition(data_ != 0,
993 "BasicImage::end(): image must have non-zero size.");
1029 typedef typename column_iterator::BaseType Iter;
1044 typedef typename const_column_iterator::BaseType Iter;
1079 void resizeImpl(
int width,
int height,
value_type const & d,
bool skipInit);
1085 PIXELTYPE ** lines_;
1086 int width_, height_;
1088 LineAllocator pallocator_;
1091 template <
class PIXELTYPE,
class Alloc>
1092 BasicImage<PIXELTYPE, Alloc> &
1097 if((width() != rhs.
width()) ||
1098 (height() != rhs.
height()))
1108 for(; is != iend; ++is, ++id) *
id = *is;
1114 template <
class PIXELTYPE,
class Alloc>
1121 for(; i != iend; ++i) *i = pixel;
1126 template <
class PIXELTYPE,
class Alloc>
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 int newsize = width*height;
1194 if (width_ != width || height_ != height)
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>
1262 BasicImage<PIXELTYPE, Alloc>::initLineStartArray(value_type * data,
int width,
int height)
1264 value_type ** lines = pallocator_.allocate(
typename Alloc::size_type(height));
1265 for(
int 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,
1278 typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1279 srcImageRange(BasicImage<PixelType, Alloc>
const & img, Accessor a)
1281 return triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1282 typename BasicImage<PixelType, Alloc>::const_traverser,
1283 Accessor>(img.upperLeft(),
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>
1291 srcImageRange(BasicImage<PixelType, Alloc>
const & img, Rect2D
const & roi, Accessor a)
1293 vigra_precondition(roi.left() >= 0 && roi.top() >= 0 &&
1294 roi.right() <= img.width() && roi.bottom() <= img.height(),
1295 "srcImageRange(): ROI rectangle outside image.");
1296 return triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1297 typename BasicImage<PixelType, Alloc>::const_traverser,
1298 Accessor>(img.upperLeft() + roi.upperLeft(),
1299 img.upperLeft() + roi.lowerRight(),
1303 template <
class PixelType,
class Accessor,
class Alloc>
1304 inline pair<typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1305 srcImage(BasicImage<PixelType, Alloc>
const & img, Accessor a)
1307 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1308 Accessor>(img.upperLeft(), a);
1311 template <
class PixelType,
class Accessor,
class Alloc>
1312 inline pair<typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1313 srcImage(BasicImage<PixelType, Alloc>
const & img, Point2D
const & ul, Accessor a)
1315 vigra_precondition(img.isInside(ul),
1316 "srcImage(): ROI rectangle outside image.");
1317 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1318 Accessor>(img.upperLeft() + ul, a);
1321 template <
class PixelType,
class Accessor,
class Alloc>
1322 inline triple<typename BasicImage<PixelType, Alloc>::traverser,
1323 typename BasicImage<PixelType, Alloc>::traverser, Accessor>
1324 destImageRange(BasicImage<PixelType, Alloc> & img, Accessor a)
1326 return triple<typename BasicImage<PixelType, Alloc>::traverser,
1327 typename BasicImage<PixelType, Alloc>::traverser,
1328 Accessor>(img.upperLeft(),
1333 template <
class PixelType,
class Accessor,
class Alloc>
1334 inline triple<typename BasicImage<PixelType, Alloc>::traverser,
1335 typename BasicImage<PixelType, Alloc>::traverser, Accessor>
1336 destImageRange(BasicImage<PixelType, Alloc> & img, Rect2D
const & roi, Accessor a)
1338 vigra_precondition(roi.left() >= 0 && roi.top() >= 0 &&
1339 roi.right() <= img.width() && roi.bottom() <= img.height(),
1340 "destImageRange(): ROI rectangle outside image.");
1341 return triple<typename BasicImage<PixelType, Alloc>::traverser,
1342 typename BasicImage<PixelType, Alloc>::traverser,
1343 Accessor>(img.upperLeft() + roi.upperLeft(),
1344 img.upperLeft() + roi.lowerRight(),
1348 template <
class PixelType,
class Accessor,
class Alloc>
1349 inline pair<typename BasicImage<PixelType, Alloc>::traverser, Accessor>
1350 destImage(BasicImage<PixelType, Alloc> & img, Accessor a)
1352 return pair<typename BasicImage<PixelType, Alloc>::traverser,
1353 Accessor>(img.upperLeft(), a);
1356 template <
class PixelType,
class Accessor,
class Alloc>
1357 inline pair<typename BasicImage<PixelType, Alloc>::traverser, Accessor>
1358 destImage(BasicImage<PixelType, Alloc> & img, Point2D
const & ul, Accessor a)
1360 vigra_precondition(img.isInside(ul),
1361 "destImage(): ROI rectangle outside image.");
1362 return pair<typename BasicImage<PixelType, Alloc>::traverser,
1363 Accessor>(img.upperLeft() + ul, a);
1366 template <
class PixelType,
class Accessor,
class Alloc>
1367 inline pair<typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1368 maskImage(BasicImage<PixelType, Alloc>
const & img, Accessor a)
1370 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1371 Accessor>(img.upperLeft(), a);
1374 template <
class PixelType,
class Accessor,
class Alloc>
1375 inline pair<typename BasicImage<PixelType, Alloc>::const_traverser, Accessor>
1376 maskImage(BasicImage<PixelType, Alloc>
const & img, Point2D
const & ul, Accessor a)
1378 vigra_precondition(img.isInside(ul),
1379 "maskImage(): ROI rectangle outside image.");
1380 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1381 Accessor>(img.upperLeft() + ul, a);
1386 template <
class PixelType,
class Alloc>
1387 inline triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1388 typename BasicImage<PixelType, Alloc>::const_traverser,
1389 typename BasicImage<PixelType, Alloc>::ConstAccessor>
1390 srcImageRange(BasicImage<PixelType, Alloc>
const & img)
1392 return triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1393 typename BasicImage<PixelType, Alloc>::const_traverser,
1394 typename BasicImage<PixelType, Alloc>::ConstAccessor>(img.upperLeft(),
1399 template <
class PixelType,
class Alloc>
1400 inline triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1401 typename BasicImage<PixelType, Alloc>::const_traverser,
1402 typename BasicImage<PixelType, Alloc>::ConstAccessor>
1403 srcImageRange(BasicImage<PixelType, Alloc>
const & img, Rect2D
const & roi)
1405 vigra_precondition(roi.left() >= 0 && roi.top() >= 0 &&
1406 roi.right() <= img.width() && roi.bottom() <= img.height(),
1407 "srcImageRange(): ROI rectangle outside image.");
1408 return triple<typename BasicImage<PixelType, Alloc>::const_traverser,
1409 typename BasicImage<PixelType, Alloc>::const_traverser,
1410 typename BasicImage<PixelType, Alloc>::ConstAccessor>(img.upperLeft() + roi.upperLeft(),
1411 img.upperLeft() + roi.lowerRight(),
1415 template <
class PixelType,
class Alloc>
1416 inline pair< typename BasicImage<PixelType, Alloc>::const_traverser,
1417 typename BasicImage<PixelType, Alloc>::ConstAccessor>
1418 srcImage(BasicImage<PixelType, Alloc>
const & img)
1420 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1421 typename BasicImage<PixelType, Alloc>::ConstAccessor>(img.upperLeft(),
1425 template <
class PixelType,
class Alloc>
1426 inline pair< typename BasicImage<PixelType, Alloc>::const_traverser,
1427 typename BasicImage<PixelType, Alloc>::ConstAccessor>
1428 srcImage(BasicImage<PixelType, Alloc>
const & img, Point2D
const & ul)
1430 vigra_precondition(img.isInside(ul),
1431 "srcImage(): ROI rectangle outside image.");
1432 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1433 typename BasicImage<PixelType, Alloc>::ConstAccessor>(img.upperLeft() + ul,
1437 template <
class PixelType,
class Alloc>
1438 inline triple< typename BasicImage<PixelType, Alloc>::traverser,
1439 typename BasicImage<PixelType, Alloc>::traverser,
1440 typename BasicImage<PixelType, Alloc>::Accessor>
1441 destImageRange(BasicImage<PixelType, Alloc> & img)
1443 return triple<typename BasicImage<PixelType, Alloc>::traverser,
1444 typename BasicImage<PixelType, Alloc>::traverser,
1445 typename BasicImage<PixelType, Alloc>::Accessor>(img.upperLeft(),
1450 template <
class PixelType,
class Alloc>
1451 inline triple< typename BasicImage<PixelType, Alloc>::traverser,
1452 typename BasicImage<PixelType, Alloc>::traverser,
1453 typename BasicImage<PixelType, Alloc>::Accessor>
1454 destImageRange(BasicImage<PixelType, Alloc> & img, Rect2D
const & roi)
1456 vigra_precondition(roi.left() >= 0 && roi.top() >= 0 &&
1457 roi.right() <= img.width() && roi.bottom() <= img.height(),
1458 "destImageRange(): ROI rectangle outside image.");
1459 return triple<typename BasicImage<PixelType, Alloc>::traverser,
1460 typename BasicImage<PixelType, Alloc>::traverser,
1461 typename BasicImage<PixelType, Alloc>::Accessor>(img.upperLeft() + roi.upperLeft(),
1462 img.upperLeft() + roi.lowerRight(),
1466 template <
class PixelType,
class Alloc>
1467 inline pair< typename BasicImage<PixelType, Alloc>::traverser,
1468 typename BasicImage<PixelType, Alloc>::Accessor>
1469 destImage(BasicImage<PixelType, Alloc> & img)
1471 return pair<typename BasicImage<PixelType, Alloc>::traverser,
1472 typename BasicImage<PixelType, Alloc>::Accessor>(img.upperLeft(),
1476 template <
class PixelType,
class Alloc>
1477 inline pair< typename BasicImage<PixelType, Alloc>::traverser,
1478 typename BasicImage<PixelType, Alloc>::Accessor>
1479 destImage(BasicImage<PixelType, Alloc> & img, Point2D
const & ul)
1481 vigra_precondition(img.isInside(ul),
1482 "destImage(): ROI rectangle outside image.");
1483 return pair<typename BasicImage<PixelType, Alloc>::traverser,
1484 typename BasicImage<PixelType, Alloc>::Accessor>(img.upperLeft() + ul,
1488 template <
class PixelType,
class Alloc>
1489 inline pair< typename BasicImage<PixelType, Alloc>::const_traverser,
1490 typename BasicImage<PixelType, Alloc>::ConstAccessor>
1491 maskImage(BasicImage<PixelType, Alloc>
const & img)
1493 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1494 typename BasicImage<PixelType, Alloc>::ConstAccessor>(img.upperLeft(),
1498 template <
class PixelType,
class Alloc>
1499 inline pair< typename BasicImage<PixelType, Alloc>::const_traverser,
1500 typename BasicImage<PixelType, Alloc>::ConstAccessor>
1501 maskImage(BasicImage<PixelType, Alloc>
const & img, Point2D
const & ul)
1503 vigra_precondition(img.isInside(ul),
1504 "maskImage(): ROI rectangle outside image.");
1505 return pair<typename BasicImage<PixelType, Alloc>::const_traverser,
1506 typename BasicImage<PixelType, Alloc>::ConstAccessor>(img.upperLeft() + ul,
1511 #undef VIGRA_ASSERT_INSIDE
1512 #endif // VIGRA_BASICIMAGE_HXX