diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1df09d3c..7a6d7a99 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -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)
diff --git a/doc/images/pirect.png b/doc/images/pirect.png
new file mode 100644
index 00000000..a1b8b105
Binary files /dev/null and b/doc/images/pirect.png differ
diff --git a/libs/main/core/pivariant.cpp b/libs/main/core/pivariant.cpp
index 3eda416f..98d1eb4e 100644
--- a/libs/main/core/pivariant.cpp
+++ b/libs/main/core/pivariant.cpp
@@ -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. */
diff --git a/libs/main/core/pivariant.h b/libs/main/core/pivariant.h
index fe155eef..0db863d8 100644
--- a/libs/main/core/pivariant.h
+++ b/libs/main/core/pivariant.h
@@ -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)
 
diff --git a/libs/main/math/piline.h b/libs/main/math/piline.h
index 4697e98a..03c489fa 100644
--- a/libs/main/math/piline.h
+++ b/libs/main/math/piline.h
@@ -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
diff --git a/libs/main/math/pipoint.h b/libs/main/math/pipoint.h
index 660bbdcd..401518a4 100644
--- a/libs/main/math/pipoint.h
+++ b/libs/main/math/pipoint.h
@@ -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());}
diff --git a/libs/main/math/pirect.h b/libs/main/math/pirect.h
index b0eabe95..6f82cdad 100644
--- a/libs/main/math/pirect.h
+++ b/libs/main/math/pirect.h
@@ -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;
 }