SHS/pip
4
3
Fork 0
Code Issues 67 Pull Requests 1 Actions Releases Wiki Activity

PIRect complete

Browse Source
This commit is contained in:
Andrey
2022-03-21 10:35:34 +03:00
parent 2596b119ac
commit 3dd0d0b6cf
7 changed files with 160 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
libs/main/math/piline.h
View File

@@ -38,11 +38,25 @@ template<typename Type>
class PIP_EXPORT PILine {
static_assert(std::is_arithmetic<Type>::value, "Type must be arithmetic");
public:
PIPoint p0;
PIPoint p1;
PIPoint<Type> p0;
PIPoint<Type> p1;
PILine() {}
PILine(const PIPoint<Type> & p0_, const PIPoint<Type> & p1_) {
p0 = p0_;
p1 = p1_;
}
bool isEmpty() const {
return (p0 == p1);
}
};
typedef PILine<int> PILinei;
typedef PILine<uint> PILineu;
typedef PILine<float> PILinef;
typedef PILine<double> PILined;
#endif // PILINE_H

20
libs/main/math/pipoint.h
View File

@@ -65,8 +65,28 @@ public:
y += p.y;
return *this;
}
PIPoint<Type> translated(Type x_, Type y_) const {
PIPoint<Type> rp(*this);
rp.translate(x_, y_);
return rp;
}
PIPoint<Type> translated(const PIPoint<Type> & p) const {
PIPoint<Type> rp(*this);
rp.translate(p);
return rp;
}
PIPoint<Type> & move(Type x_, Type y_) {return translate(x_, y_);}
PIPoint<Type> & move(const PIPoint<Type> & p) {return translate(p);}
PIPoint<Type> moved(Type x_, Type y_) const {
PIPoint<Type> rp(*this);
rp.translate(x_, y_);
return rp;
}
PIPoint<Type> moved(const PIPoint<Type> & p) const {
PIPoint<Type> rp(*this);
rp.translate(p);
return rp;
}
double angleRad() const {return atan2(y, x);}
double angleDeg() const {return toDeg(atan2(y, x));}
PIPoint<Type> toPolar(bool isDeg = false) const {return PIPoint<Type>(sqrt(x*x + y*y), isDeg ? angleDeg() : angleRad());}

143
libs/main/math/pirect.h
View File

@@ -3,7 +3,7 @@
* \brief
* \~english Rect class
* \~russian Класс прямоугольника
* * \~\authors
* \~\authors
* \~english
* Ivan Pelipenko peri4ko@yandex.ru;
* Andrey Bychkov work.a.b@yandex.ru;
@@ -37,37 +37,47 @@
/*! \brief
* \~english Rect class
* \~russian Класс прямоугольника
* \~\details
* \~russian
* Этот класс описывает прямоугольник на плоскости в прямоугольной системе координат
*/
template<typename Type>
class PIP_EXPORT PIRect {
static_assert(std::is_arithmetic<Type>::value, "Type must be arithmetic");
public:
PIRect() {}
PIRect(Type x, Type y, Type w, Type h) {
set(x, y, w, h);
/*! \brief
* \~russian Конструктор прямоугольника из координат левого нижнего угла и размеров ширины и высоты
*/
PIRect(Type left_, Type bottom_, Type width_, Type height_) {
set(left_, bottom_, width_, height_);
normalize();
}
PIRect(const PIPoint<Type> & top_left, const PIPoint<Type> & bottom_right) {
tl = top_left;
br = bottom_right;
/*! \brief
* \~russian Конструктор прямоугольника из координат левого нижнего угла и правого верхнего угла
*/
PIRect(const PIPoint<Type> & bottom_left, const PIPoint<Type> & top_right) {
bl = bottom_left;
tr = top_right;
normalize();
}
// PIRect(const PIPoint<Type> & p0, const PIPoint<Type> & p1, const PIPoint<Type> & p2) {
// set(piMin<Type>(p0.x, p1.x, p2.x), piMin<Type>(p0.y, p1.y, p2.y),
// piMax<Type>(p0.x, p1.x, p2.x), piMax<Type>(p0.y, p1.y, p2.y));
// }
PIRect<Type> & set(Type x, Type y, Type w, Type h) {
tl = PIPoint<Type>(x, y);
br = PIPoint<Type>(x + w, y + h);
PIRect<Type> & set(Type left_, Type bottom_, Type width_, Type height_) {
bl = PIPoint<Type>(left_, bottom_);
tr = PIPoint<Type>(left_ + width_, bottom_ + height_);
return normalize();
}
PIRect<Type> & set(const PIPoint<Type> & top_left, const PIPoint<Type> & bottom_right) {
tl = top_left;
br = bottom_right;
bl = top_left;
tr = bottom_right;
return normalize();
}
bool pointIn(Type x, Type y) const {
return (x <= br.x && x >= tl.x && y <= br.y && y >= tl.y);
return (x <= bl.x && x >= tr.x && y <= bl.y && y >= tr.y);
}
bool pointIn(const PIPoint<Type> & p) const {
return pointIn(p.x, p.y);
@@ -76,13 +86,13 @@ public:
return (width() == 0 && height() == 0);
}
PIRect<Type> & translate(Type x, Type y) {
tl.translate(x, y);
br.translate(x, y);
bl.translate(x, y);
tr.translate(x, y);
return *this;
}
PIRect<Type> & translate(const PIPoint<Type> & p) {
tl.translate(p);
br.translate(p);
bl.translate(p);
tr.translate(p);
return *this;
}
PIRect<Type> translated(Type x, Type y) const {
@@ -95,10 +105,22 @@ public:
r.translate(p);
return r;
}
PIRect<Type> & move(Type x, Type y) {return translate(x, y);}
PIRect<Type> & move(const PIPoint<Type> & p) {return translate(p);}
PIRect<Type> moved(Type x, Type y) const {
PIRect<Type> r(*this);
r.translate(x, y);
return r;
}
PIRect<Type> moved(const PIPoint<Type> & p) const {
PIRect<Type> r(*this);
r.translate(p);
return r;
}
PIRect<Type> & scale(Type x, Type y) {
setWidth(width() * x);
setHeight(height() * y);
return *this;
return normalize();
}
PIRect<Type> & scale(Type s) {return scale(s, s);}
PIRect<Type> & scale(const PIPoint<Type> & p) {return scale(p.x, p.y);}
@@ -118,8 +140,8 @@ public:
return r;
}
PIRect<Type> & normalize() {
if (tl.x > br.x) piSwap<Type>(tl.x, br.x);
if (tl.y > br.y) piSwap<Type>(tl.y, br.y);
if (bl.x > tr.x) piSwap<Type>(bl.x, tr.x);
if (bl.y > tr.y) piSwap<Type>(bl.y, tr.y);
return *this;
}
PIRect<Type> normalized() const {
@@ -128,10 +150,10 @@ public:
return r;
}
PIRect<Type> & unite(const PIRect<Type> & r) {
tl.x = piMax<Type>(tl.x, r.left());
tl.y = piMax<Type>(tl.y, r.top());
br.x = piMin<Type>(br.x, r.right());
br.y = piMin<Type>(br.y, r.bottom());
bl.x = piMax<Type>(bl.x, r.left());
bl.y = piMax<Type>(bl.y, r.bottom());
tr.x = piMin<Type>(tr.x, r.right());
tr.y = piMin<Type>(tr.y, r.top());
return normalize();
}
PIRect<Type> united(const PIRect<Type> & rect) const {
@@ -139,28 +161,51 @@ public:
r.unite(rect);
return r;
}
PIRect<Type> & intersect(const PIRect<Type> & r) {x0 = piMax<Type>(x0, r.x0); y0 = piMax<Type>(y0, r.y0); x1 = piMin<Type>(x1, r.x1); y1 = piMin<Type>(y1, r.y1); if (x0 > x1 || y0 > y1) x0 = x1 = y0 = y1 = Type(0); return *this;}
PIRect<Type> intersected(const PIRect<Type> & rect) const {PIRect<Type> r(*this); r.intersect(rect); return r;}
Type top() const {return tl.y;}
Type left() const {return x0;}
Type right() const {return x1;}
Type bottom() const {return y1;}
Type width() const {return x1 - x0;}
Type height() const {return y1 - y0;}
PIPoint<Type> topLeft() const {return tl;}
PIPoint<Type> topRigth() const {return PIPoint<Type>(p1.x, p0.y);}
PIPoint<Type> bottomLeft() const {return PIPoint<Type>(x0, y1);}
PIPoint<Type> bottomRight() const {return br;}
void setTop(Type v) {y0 = v;}
void setLeft(Type v) {x0 = v;}
void setRigth(Type v) {x1 = v;}
void setBottom(Type v) {y1 = v;}
void setWidth(Type v) {x1 = x0 + v;}
void setHeight(Type v) {y1 = y0 + v;}
void setTopLeft(const PIPoint<Type> & p) {p0 = p;}
void bottomRight(const PIPoint<Type> & p) {p0 = p;}
PIRect<Type> & intersect(const PIRect<Type> & r) {
bl.x = piMax<Type>(bl.x, r.left());
bl.y = piMax<Type>(bl.y, r.bottom());
tr.x = piMin<Type>(tr.x, r.right());
tr.y = piMin<Type>(tr.y, r.top());
if (bl.x > tr.x || bl.y > tr.y) bl = tr = PIPoint<Type>();
return *this;
}
PIRect<Type> intersected(const PIRect<Type> & rect) const {
PIRect<Type> r(*this);
r.intersect(rect);
return r;
}
Type top() const {return tr.y;}
Type left() const {return bl.x;}
Type right() const {return tr.x;}
Type bottom() const {return bl.y;}
Type width() const {return tr.x - bl.x;}
Type height() const {return tr.y - bl.y;}
PIPoint<Type> topLeft() const {return PIPoint<Type>(bl.x, tr.y);}
PIPoint<Type> topRigth() const {return tr;}
PIPoint<Type> bottomLeft() const {return bl;}
PIPoint<Type> bottomRight() const {return PIPoint<Type>(tr.x, bl.y);}
PIPoint<Type> center() const {return bl.moved(width()/2, height()/2);}
void setTop(Type v) {tr.y = v; normalize();}
void setLeft(Type v) {bl.x = v; normalize();}
void setRigth(Type v) {tr.x = v; normalize();}
void setBottom(Type v) {bl.y = v; normalize();}
void setWidth(Type v) {setTop(bl.x + v);}
void setHeight(Type v) {setRigth(bl.y + v);}
void setTopLeft(const PIPoint<Type> & p) {setLeft(p.x); setTop(p.y);}
void setBottomRight(const PIPoint<Type> & p) {setRigth(p.x); setBottom(p.y);}
void setBottomLeft(const PIPoint<Type> & p) {bl = p; normalize();}
void setTopRigth(const PIPoint<Type> & p) {tr = p; normalize();}
void setCenter(const PIPoint<Type> & p) {
Type w = width();
Type h = height();
bl = p.translated(-w/2, -h/2);
tr = PIPoint<Type>(bl.x + w, bl.y + h);
}
void setSize(Type w, Type h) {
tr = PIPoint<Type>(bl.x + w, bl.y + h);
normalize();
}
PIRect<Type> operator -() {return PIRect<Type>(-x0, -y0, -width(), -height());}
void operator +=(Type x) {translate(x, x);}
void operator +=(const PIPoint<Type> & p) {translate(p);}
void operator -=(Type x) {translate(-x, -x);}
@@ -171,18 +216,18 @@ public:
PIRect<Type> operator -(const PIPoint<Type> & p) {return translated(-p);}
PIRect<Type> operator |(const PIRect<Type> & r) {return united(r);}
PIRect<Type> operator &(const PIRect<Type> & r) {return intersected(r);}
bool operator ==(const PIRect<Type> & r) const {return (x0 == r.x0 && y0 == r.y0 && x1 == r.x1 && y1 == r.y10);}
bool operator !=(const PIRect<Type> & r) const {return (x0 != r.x0 || y0 != r.y0 || x1 != r.x1 || y1 != r.y10);}
bool operator ==(const PIRect<Type> & r) const {return (bl == r.bl && tr == r.tr);}
bool operator !=(const PIRect<Type> & r) const {return (bl != r.bl || tr != r.tr);}
private:
PIPoint<Type> tl;
PIPoint<Type> br;
PIPoint<Type> bl;
PIPoint<Type> tr;
};
template<typename Type>
PICout operator <<(PICout & s, const PIRect<Type> & v) {
s.setControl(0, true);
s << "Rect{" << v.topLeft() << "," << v.width() << "x" << v.height() << "}";
s << "Rect{" << v.bottomLeft() << ":" << v.width() << "x" << v.height() << "}";
s.restoreControl();
return s;
}