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

4
CMakeLists.txt
View File

@@ -2,8 +2,8 @@ cmake_minimum_required(VERSION 3.0)
cmake_policy(SET CMP0017 NEW) # need include() with .cmake
project(pip)
set(pip_MAJOR 2)
set(pip_MINOR 33)
set(pip_REVISION 1)
set(pip_MINOR 34)
set(pip_REVISION 0)
set(pip_SUFFIX )
set(pip_COMPANY SHS)
set(pip_DOMAIN org.SHS)

BIN
doc/images/pirect.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 106 KiB

10
libs/main/core/pivariant.cpp
View File

@@ -619,6 +619,16 @@ PIRectd PIVariant::toRect() const {
}
/** @brief Returns variant content as rect
* \details In case of PILined type returns line value. \n
* In case of other types returns empty PILined. */
PILined PIVariant::toLine() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivLine) {PILined r; ba >> r; return r;}
return PILined();
}
/** @brief Returns variant content as math vector
* \details In case of PIMathVectord type returns rect value. \n
* In case of other types returns empty PIMathVectord. */

22
libs/main/core/pivariant.h
View File

@@ -234,11 +234,12 @@ public:
pivFile /** PIVariantTypes::File */ ,
pivDir /** PIVariantTypes::Dir */ ,
pivColor /** PIVariantTypes::Color */ ,
pivPoint /** PIPoint */ ,
pivRect /** PIRect */ ,
pivPoint /** PIPoint<double> */ ,
pivRect /** PIRect<double> */ ,
pivIODevice /** PIVariantTypes::IODevice */ ,
pivMathVector /** PIMathVectord */ ,
pivMathMatrix /** PIMathMatrixd */ ,
pivMathVector /** PIMathVector<double> */ ,
pivMathMatrix /** PIMathMatrix<double> */ ,
pivLine /** PILine<double> */ ,
pivCustom /** Custom */ = 0xFF
};
@@ -333,6 +334,9 @@ public:
//! Constructs variant from rect
PIVariant(const PIRectd & v) {initType(v);}
//! Constructs variant from line
PIVariant(const PILined & v) {initType(v);}
//! Constructs variant from MathVector
PIVariant(const PIMathVectord & v) {initType(v);}
@@ -424,6 +428,9 @@ public:
//! Set variant content and type to rect
void setValue(const PIRectd & v) {initType(v);}
//! Set variant content and type to line
void setValue(const PILined & v) {initType(v);}
//! Set variant content and type to math vector
void setValue(const PIMathVectord & v) {initType(v);}
@@ -456,6 +463,7 @@ public:
PIVariantTypes::IODevice toIODevice() const;
PIPointd toPoint() const;
PIRectd toRect() const;
PILined toLine() const;
PIMathVectord toMathVector() const;
PIMathMatrixd toMathMatrix() const;
@@ -527,6 +535,8 @@ public:
//! Assign operator
PIVariant & operator =(const PIRectd & v) {setValue(v); return *this;}
//! Assign operator
PIVariant & operator =(const PILined & v) {setValue(v); return *this;}
//! Assign operator
PIVariant & operator =(const PIMathVectord & v) {setValue(v); return *this;}
//! Assign operator
PIVariant & operator =(const PIMathMatrixd & v) {setValue(v); return *this;}
@@ -661,6 +671,7 @@ template<> inline PIVariantTypes::Color PIVariant::value() const {return toColor
template<> inline PIVariantTypes::IODevice PIVariant::value() const {return toIODevice();}
template<> inline PIPointd PIVariant::value() const {return toPoint();}
template<> inline PIRectd PIVariant::value() const {return toRect();}
template<> inline PILined PIVariant::value() const {return toLine();}
template<> inline PIVariant PIVariant::value() const {return *this;}
template<> inline PIVariant PIVariant::fromValue(const bool & v) {return PIVariant(v);}
@@ -690,6 +701,7 @@ template<> inline PIVariant PIVariant::fromValue(const PIVariantTypes::Color & v
template<> inline PIVariant PIVariant::fromValue(const PIVariantTypes::IODevice & v) {return PIVariant(v);}
template<> inline PIVariant PIVariant::fromValue(const PIPointd & v) {return PIVariant(v);}
template<> inline PIVariant PIVariant::fromValue(const PIRectd & v) {return PIVariant(v);}
template<> inline PIVariant PIVariant::fromValue(const PILined & v) {return PIVariant(v);}
template<> inline PIVariant PIVariant::fromValue(const PIMathVectord & v) {return PIVariant(v);}
template<> inline PIVariant PIVariant::fromValue(const PIMathMatrixd & v) {return PIVariant(v);}
template<> inline PIVariant PIVariant::fromValue(const PIVariant & v) {return PIVariant(v);}
@@ -721,6 +733,7 @@ template<> inline PIVariant::Type PIVariant::getType<PIVariantTypes::Color>() {r
template<> inline PIVariant::Type PIVariant::getType<PIVariantTypes::IODevice>() {return PIVariant::pivIODevice;}
template<> inline PIVariant::Type PIVariant::getType<PIPointd>() {return PIVariant::pivPoint;}
template<> inline PIVariant::Type PIVariant::getType<PIRectd>() {return PIVariant::pivRect;}
template<> inline PIVariant::Type PIVariant::getType<PILined>() {return PIVariant::pivLine;}
template<> inline PIVariant::Type PIVariant::getType<PIMathVectord>() {return PIVariant::pivMathVector;}
template<> inline PIVariant::Type PIVariant::getType<PIMathMatrixd>() {return PIVariant::pivMathMatrix;}
@@ -751,6 +764,7 @@ REGISTER_NS_VARIANT(PIVariantTypes, Color)
REGISTER_NS_VARIANT(PIVariantTypes, IODevice)
REGISTER_VARIANT(PIPointd)
REGISTER_VARIANT(PIRectd)
REGISTER_VARIANT(PILined)
REGISTER_VARIANT(PIMathVectord)
REGISTER_VARIANT(PIMathMatrixd)

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;
}