36 #ifndef VIGRA_DIFF2D_HXX
37 #define VIGRA_DIFF2D_HXX
42 #include "iteratortags.hxx"
43 #include "iteratortraits.hxx"
44 #include "iteratoradapter.hxx"
52 class Diff2DConstRowIteratorPolicy
55 typedef Diff BaseType;
56 typedef Diff value_type;
57 typedef typename Diff::MoveX difference_type;
58 typedef Diff
const & reference;
59 typedef Diff index_reference;
60 typedef Diff
const * pointer;
61 typedef std::random_access_iterator_tag iterator_category;
63 static void initialize(BaseType &) {}
65 static reference dereference(BaseType
const & d)
68 static index_reference dereference(BaseType d, difference_type n)
74 static bool equal(BaseType
const & d1, BaseType
const & d2)
75 {
return d1.x == d2.x; }
77 static bool less(BaseType
const & d1, BaseType
const & d2)
78 {
return d1.x < d2.x; }
80 static difference_type difference(BaseType
const & d1, BaseType
const & d2)
81 {
return d1.x - d2.x; }
83 static void increment(BaseType & d)
86 static void decrement(BaseType & d)
89 static void advance(BaseType & d, difference_type n)
94 class Diff2DConstColumnIteratorPolicy
97 typedef Diff BaseType;
98 typedef Diff value_type;
99 typedef typename Diff::MoveY difference_type;
100 typedef Diff
const & reference;
101 typedef Diff index_reference;
102 typedef Diff
const * pointer;
103 typedef std::random_access_iterator_tag iterator_category;
105 static void initialize(BaseType & ) {}
107 static reference dereference(BaseType
const & d)
110 static index_reference dereference(BaseType d, difference_type n)
116 static bool equal(BaseType
const & d1, BaseType
const & d2)
117 {
return d1.y == d2.y; }
119 static bool less(BaseType
const & d1, BaseType
const & d2)
120 {
return d1.y < d2.y; }
122 static difference_type difference(BaseType
const & d1, BaseType
const & d2)
123 {
return d1.y - d2.y; }
125 static void increment(BaseType & d)
128 static void decrement(BaseType & d)
131 static void advance(BaseType & d, difference_type n)
300 x = (int)(
x * factor);
301 y = (int)(
y * factor);
318 x = (int)(
x / factor);
319 y = (int)(
y / factor);
327 return Diff2D(
x * factor,
y * factor);
334 return Diff2D((
int)(
x * factor), (
int)(
y * factor));
341 return Diff2D(
x / factor,
y / factor);
348 return Diff2D((
int)(
x / factor), (
int)(
y / factor));
369 return (
x == r.
x) && (
y == r.
y);
376 return (
x != r.
x) || (
y != r.
y);
442 struct IteratorTraits<Diff2D >
444 typedef Diff2D Iterator;
445 typedef Iterator iterator;
446 typedef Iterator const_iterator;
448 typedef iterator::iterator_category iterator_category;
449 typedef iterator::value_type value_type;
450 typedef iterator::reference reference;
451 typedef iterator::index_reference index_reference;
452 typedef iterator::pointer pointer;
453 typedef iterator::difference_type difference_type;
454 typedef iterator::row_iterator row_iterator;
455 typedef iterator::column_iterator column_iterator;
456 typedef StandardConstValueAccessor<Diff2D> DefaultAccessor;
457 typedef StandardConstValueAccessor<Diff2D> default_accessor;
458 typedef VigraTrueType hasConstantStrides;
720 return Size2D(s.
x - offset.
x, s.
y - offset.
y);
765 inline Point2D operator*(Point2D l,
double r)
771 inline Point2D operator*(
double l, Point2D r)
777 inline Size2D operator*(Size2D l,
double r)
783 inline Size2D operator*(
double l, Size2D r)
789 inline Point2D operator/(Point2D l,
double r)
795 inline Size2D operator/(Size2D l,
double r)
801 inline Point2D operator*(Point2D l,
int r)
807 inline Point2D operator*(
int l, Point2D r)
813 inline Size2D operator*(Size2D l,
int r)
819 inline Size2D operator*(
int l, Size2D r)
825 inline Point2D operator/(Point2D l,
int r)
831 inline Size2D operator/(Size2D l,
int r)
874 Point2D upperLeft_, lowerRight_;
945 lowerRight_ += newUpperLeft - upperLeft_;
946 upperLeft_ = newUpperLeft;
961 upperLeft_ += offset;
962 lowerRight_ += offset;
991 return lowerRight_.
x;
999 return lowerRight_.
y;
1007 return lowerRight_.
x - upperLeft_.
x;
1015 return lowerRight_.
y - upperLeft_.
y;
1033 return lowerRight_ - upperLeft_;
1041 lowerRight_ = upperLeft_ +
size;
1059 lowerRight_ += offset;
1069 upperLeft_ +=
Diff2D(-borderWidth, -borderWidth);
1070 lowerRight_ +=
Diff2D(borderWidth, borderWidth);
1082 upperLeft_ +=
Diff2D(-borderWidth, -borderHeight);
1083 lowerRight_ +=
Diff2D(borderWidth, borderHeight);
1089 return (upperLeft_ == r.upperLeft_) && (lowerRight_ == r.lowerRight_);
1095 return (upperLeft_ != r.upperLeft_) || (lowerRight_ != r.lowerRight_);
1107 return ((lowerRight_.
x <= upperLeft_.
x) ||
1108 (lowerRight_.
y <= upperLeft_.
y));
1118 return ((upperLeft_.
x <= p.
x) &&
1119 (upperLeft_.
y <= p.
y) &&
1120 (p.
x < lowerRight_.
x) &&
1121 (p.
y < lowerRight_.
y));
1143 return ((r.upperLeft_.
x < lowerRight_.
x) &&
1144 (upperLeft_.
x < r.lowerRight_.
x) &&
1145 (r.upperLeft_.
y < lowerRight_.
y) &&
1146 (upperLeft_.
y < r.lowerRight_.
y))
1160 lowerRight_ = p +
Diff2D(1, 1);
1164 if(p.
x < upperLeft_.
x)
1166 if(p.
y < upperLeft_.
y)
1168 if(lowerRight_.
x <= p.
x)
1169 lowerRight_.
x = p.
x + 1;
1170 if(lowerRight_.
y <= p.
y)
1171 lowerRight_.
y = p.
y + 1;
1198 return operator=(r);
1200 if(r.upperLeft_.
x < upperLeft_.
x)
1201 upperLeft_.
x = r.upperLeft_.
x;
1202 if(r.upperLeft_.
y < upperLeft_.
y)
1203 upperLeft_.
y = r.upperLeft_.
y;
1204 if(lowerRight_.
x < r.lowerRight_.
x)
1205 lowerRight_.
x = r.lowerRight_.
x;
1206 if(lowerRight_.
y < r.lowerRight_.
y)
1207 lowerRight_.
y = r.lowerRight_.
y;
1233 lowerRight_ = p +
Diff2D(1, 1);
1236 lowerRight_ = upperLeft_;
1262 return operator=(r);
1264 if(upperLeft_.
x < r.upperLeft_.
x)
1265 upperLeft_.
x = r.upperLeft_.
x;
1266 if(upperLeft_.
y < r.upperLeft_.
y)
1267 upperLeft_.
y = r.upperLeft_.
y;
1268 if(r.lowerRight_.
x < lowerRight_.
x)
1269 lowerRight_.
x = r.lowerRight_.
x;
1270 if(r.lowerRight_.
y < lowerRight_.
y)
1271 lowerRight_.
y = r.lowerRight_.
y;
1281 upperLeft_ *= factor;
1282 lowerRight_ *= factor;
1292 upperLeft_ *= factor;
1293 lowerRight_ *= factor;
1303 return Rect2D(*
this)*=factor;
1312 return Rect2D(*
this)*=factor;
1340 Dist2D(
int the_width,
int the_height)
1377 {
return Diff2D(width, height); }
1396 o <<
'(' << d.
x <<
", " << d.
y <<
')';
1407 s <<
'(' << d.
x <<
'x' << d.
y <<
')';
1419 <<
" = " << r.
size() <<
"]";
Two dimensional difference vector.
Definition: diff2d.hxx:186
bool operator==(Diff2D const &r) const
Definition: diff2d.hxx:367
int squaredMagnitude() const
Definition: diff2d.hxx:353
int y
Definition: diff2d.hxx:392
Diff2D operator*(double factor) const
Definition: diff2d.hxx:332
int MoveY
Definition: diff2d.hxx:229
int operator[](int index) const
Definition: diff2d.hxx:417
Diff2D & operator*=(double factor)
Definition: diff2d.hxx:298
Diff2D operator/(double factor) const
Definition: diff2d.hxx:346
IteratorAdaptor< Diff2DConstRowIteratorPolicy< Diff2D > > row_iterator
Definition: diff2d.hxx:218
int x
Definition: diff2d.hxx:385
Diff2D(Diff2D const &v)
Definition: diff2d.hxx:246
Diff2D & operator+=(Diff2D const &offset)
Definition: diff2d.hxx:271
Diff2D index_reference
Definition: diff2d.hxx:202
index_reference operator()(int const &dx, int const &dy) const
Definition: diff2d.hxx:403
Diff2D & operator/=(int factor)
Definition: diff2d.hxx:307
bool operator!=(Diff2D const &r) const
Definition: diff2d.hxx:374
Diff2D & operator-=(Diff2D const &offset)
Definition: diff2d.hxx:280
row_iterator rowIterator() const
Definition: diff2d.hxx:431
Diff2D const * pointer
Definition: diff2d.hxx:206
image_traverser_tag iterator_category
Definition: diff2d.hxx:214
int MoveX
Definition: diff2d.hxx:226
index_reference operator[](Diff2D const &offset) const
Definition: diff2d.hxx:410
Diff2D & operator*=(int factor)
Definition: diff2d.hxx:289
Diff2D & operator=(Diff2D const &v)
Definition: diff2d.hxx:252
Diff2D()
Definition: diff2d.hxx:234
Diff2D PixelType
Definition: diff2d.hxx:190
reference operator*() const
Definition: diff2d.hxx:396
Diff2D operator-() const
Definition: diff2d.hxx:264
Diff2D const & reference
Definition: diff2d.hxx:198
IteratorAdaptor< Diff2DConstColumnIteratorPolicy< Diff2D > > column_iterator
Definition: diff2d.hxx:222
Diff2D operator*(int factor) const
Definition: diff2d.hxx:325
Diff2D value_type
Definition: diff2d.hxx:194
column_iterator columnIterator() const
Definition: diff2d.hxx:436
pointer operator->() const
Definition: diff2d.hxx:424
Diff2D(int ax, int ay)
Definition: diff2d.hxx:240
Diff2D & operator/=(double factor)
Definition: diff2d.hxx:316
double magnitude() const
Definition: diff2d.hxx:360
Diff2D difference_type
Definition: diff2d.hxx:210
Diff2D operator/(int factor) const
Definition: diff2d.hxx:339
Definition: diff2d.hxx:1338
Quickly create 1-dimensional iterator adapters.
Definition: iteratoradapter.hxx:148
Two dimensional point or position.
Definition: diff2d.hxx:593
Point2D operator-() const
Definition: diff2d.hxx:661
Point2D(Point2D const &v)
Definition: diff2d.hxx:628
Point2D const * pointer
Definition: diff2d.hxx:613
Point2D(int x, int y)
Definition: diff2d.hxx:622
Point2D const & reference
Definition: diff2d.hxx:605
index_reference operator()(int const &dx, int const &dy) const
Definition: diff2d.hxx:689
Point2D(Diff2D const &v)
Definition: diff2d.hxx:634
int py() const
Definition: diff2d.hxx:647
index_reference operator[](Diff2D const &offset) const
Definition: diff2d.hxx:696
reference operator*() const
Definition: diff2d.hxx:682
Point2D & operator+=(Diff2D const &offset)
Definition: diff2d.hxx:668
Point2D PixelType
Definition: diff2d.hxx:597
Point2D index_reference
Definition: diff2d.hxx:609
Point2D()
Definition: diff2d.hxx:617
pointer operator->() const
Definition: diff2d.hxx:703
Point2D & operator=(Diff2D const &v)
Definition: diff2d.hxx:654
Point2D value_type
Definition: diff2d.hxx:601
int px() const
Definition: diff2d.hxx:640
Point2D & operator-=(Diff2D const &offset)
Definition: diff2d.hxx:675
Two dimensional rectangle.
Definition: diff2d.hxx:873
int top() const
Definition: diff2d.hxx:981
void addBorder(int borderWidth, int borderHeight)
Definition: diff2d.hxx:1080
bool contains(Rect2D const &r) const
Definition: diff2d.hxx:1130
Rect2D()
Definition: diff2d.hxx:879
void setSize(Size2D const &size)
Definition: diff2d.hxx:1039
void addBorder(int borderWidth)
Definition: diff2d.hxx:1067
Rect2D(Point2D const &upperLeft, Size2D const &size)
Definition: diff2d.hxx:898
Rect2D operator|(Rect2D const &r) const
Definition: diff2d.hxx:1216
void moveBy(Diff2D const &offset)
Definition: diff2d.hxx:959
void setSize(int width, int height)
Definition: diff2d.hxx:1047
int right() const
Definition: diff2d.hxx:989
int bottom() const
Definition: diff2d.hxx:997
Rect2D & operator&=(Point2D const &p)
Definition: diff2d.hxx:1228
void moveBy(int xOffset, int yOffset)
Definition: diff2d.hxx:967
Rect2D & operator*=(double factor)
Definition: diff2d.hxx:1290
Rect2D & operator|=(Rect2D const &r)
Definition: diff2d.hxx:1193
Point2D const & upperLeft() const
Definition: diff2d.hxx:911
void setLowerRight(Point2D const &lr)
Definition: diff2d.hxx:935
Rect2D operator*(double factor) const
Definition: diff2d.hxx:1310
void setUpperLeft(Point2D const &ul)
Definition: diff2d.hxx:927
bool operator==(Rect2D const &r) const
equality check
Definition: diff2d.hxx:1087
Rect2D operator&(Rect2D const &r) const
Definition: diff2d.hxx:1320
bool intersects(Rect2D const &r) const
Definition: diff2d.hxx:1141
void addSize(Size2D const &offset)
Definition: diff2d.hxx:1057
Rect2D & operator|=(Point2D const &p)
Definition: diff2d.hxx:1155
Rect2D(Point2D const &upperLeft, Point2D const &lowerRight)
Definition: diff2d.hxx:886
bool contains(Point2D const &p) const
Definition: diff2d.hxx:1116
void moveTo(Point2D const &newUpperLeft)
Definition: diff2d.hxx:943
int left() const
Definition: diff2d.hxx:974
bool operator!=(Rect2D const &r) const
inequality check
Definition: diff2d.hxx:1093
Rect2D operator|(Point2D const &p) const
Definition: diff2d.hxx:1181
bool isEmpty() const
Definition: diff2d.hxx:1105
int height() const
Definition: diff2d.hxx:1013
Rect2D(int left, int top, int right, int bottom)
Definition: diff2d.hxx:892
int width() const
Definition: diff2d.hxx:1005
void moveTo(int left, int top)
Definition: diff2d.hxx:952
Rect2D & operator&=(Rect2D const &r)
Definition: diff2d.hxx:1257
Rect2D operator&(Point2D const &p) const
Definition: diff2d.hxx:1245
Rect2D & operator*=(int factor)
Definition: diff2d.hxx:1279
Rect2D operator*(int factor) const
Definition: diff2d.hxx:1301
Size2D size() const
Definition: diff2d.hxx:1031
Rect2D(Size2D const &size)
Definition: diff2d.hxx:904
Point2D const & lowerRight() const
Definition: diff2d.hxx:919
int area() const
Definition: diff2d.hxx:1022
Two dimensional size object.
Definition: diff2d.hxx:483
Size2D operator-() const
Definition: diff2d.hxx:552
void setHeight(int h)
Definition: diff2d.hxx:531
Size2D(Diff2D const &v)
Definition: diff2d.hxx:504
Size2D()
Definition: diff2d.hxx:487
Size2D & operator-=(Diff2D const &offset)
Definition: diff2d.hxx:566
Size2D(int width, int height)
Definition: diff2d.hxx:492
Size2D(Size2D const &v)
Definition: diff2d.hxx:498
void setWidth(int w)
Definition: diff2d.hxx:524
Size2D & operator=(Diff2D const &v)
Definition: diff2d.hxx:545
int height() const
Definition: diff2d.hxx:517
int width() const
Definition: diff2d.hxx:510
Size2D & operator+=(Diff2D const &offset)
Definition: diff2d.hxx:559
int area() const
Definition: diff2d.hxx:538
Diff2D operator-(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:711
Diff2D operator+(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:739