// JLH 11/10/2016 Created this file
//
-#include "rect.h"
-//#include <stdio.h>
+#include "rect.h"
+#include <math.h>
Rect::Rect(): l(0), r(0), t(0), b(0)
{
}
-
-Rect::Rect(double ll, double rr, double tt, double bb):
+Rect::Rect(double tt, double ll, double bb, double rr):
l(ll), r(rr), t(tt), b(bb)
{
Normalize();
}
-
Rect::Rect(Point tl, Point br): l(tl.x), r(br.x), t(tl.y), b(br.y)
{
Normalize();
}
+Rect::Rect(Point p): l(p.x), r(p.x), t(p.y), b(p.y)
+{
+}
Rect & Rect::operator*=(double scale)
{
r *= scale;
t *= scale;
b *= scale;
+
return *this;
}
-
Rect & Rect::operator|=(Rect r2)
{
//printf("operatore|=\nthis = (%lf, %lf, %lf, %lf), r = (%lf, %lf, %lf, %lf)\n", l, t, r, b, r2.l, r2.t, r2.r, r2.b);
return *this;
}
+Rect & Rect::operator+=(Point p)
+{
+ if (p.x < l)
+ l = p.x;
+
+ if (p.x > r)
+ r = p.x;
+
+ if (p.y < b)
+ b = p.y;
+
+ if (p.y > t)
+ t = p.y;
+
+ return *this;
+}
+
+//
+// We use this to give a rect an array-like access, which allows access of the
+// rect in TLBR order (from 0 to 3). Also, values greater than 3 are treated
+// as mod 4.
+//
+double & Rect::operator[](int idx)
+{
+ idx = idx % 4;
+
+ switch (idx)
+ {
+ case 0:
+ return t;
+ case 1:
+ return l;
+ case 2:
+ return b;
+ }
+
+ return r;
+}
void Rect::Normalize(void)
{
}
}
-
void Rect::Translate(Point p)
{
l += p.x;
b += p.y;
}
-
void Rect::Expand(double amt)
{
l -= amt;
b -= amt;
}
+double Rect::Width(void)
+{
+ return fabs(r - l);
+}
+
+double Rect::Height(void)
+{
+ return fabs(t - b);
+}
+
+bool Rect::Contains(Point p)
+{
+ return ((p.x >= l) && (p.x <= r) && (p.y >= b) && (p.y <= t) ? true : false);
+}
+
+bool Rect::Contains(Rect rect)
+{
+ return ((rect.l >= l) && (rect.r <= r) && (rect.b >= b) && (rect.t <= t) ? true : false);
+}
+
+Point Rect::TopLeft(void)
+{
+ return Point(l, t);
+}
+
+Point Rect::TopRight(void)
+{
+ return Point(r, t);
+}
+
+Point Rect::BottomLeft(void)
+{
+ return Point(l, b);
+}
+
+Point Rect::BottomRight(void)
+{
+ return Point(r, b);
+}