diff --git a/geometry/varc.cpp b/geometry/varc.cpp
index 607cef99e..99721616a 100644
--- a/geometry/varc.cpp
+++ b/geometry/varc.cpp
@@ -20,8 +20,7 @@
  ****************************************************************************/
 
 #include "varc.h"
-#include <QDebug>
-#include "exception/vexception.h"
+#include <exception/vexception.h>
 
 VArc::VArc () : f1(0), formulaF1(QString()), f2(0), formulaF2(QString()), radius(0), formulaRadius(QString()),
     center(0), points(QHash<qint64, VPointF>()), mode(Draw::Calculation), idObject(0){
@@ -53,38 +52,6 @@ VArc &VArc::operator =(const VArc &arc){
     return *this;
 }
 
-qreal VArc::GetF1() const{
-    return f1;
-}
-
-QString VArc::GetFormulaF1() const{
-    return formulaF1;
-}
-
-qreal VArc::GetF2() const{
-    return f2;
-}
-
-QString VArc::GetFormulaF2() const{
-    return formulaF2;
-}
-
-qreal VArc::GetLength () const{
-    return M_PI * radius/180 * (f2-f1);
-}
-
-qreal VArc::GetRadius() const{
-    return radius;
-}
-
-QString VArc::GetFormulaRadius() const{
-    return formulaRadius;
-}
-
-qint64 VArc::GetCenter() const{
-    return center;
-}
-
 QPointF VArc::GetCenterPoint() const{
     if(points.contains(center)){
         return points.value(center).toQPointF();
@@ -197,19 +164,3 @@ QVector<QPointF> VArc::SplOfArc(qint32 number) const{
     }
     return QVector<QPointF>();
 }
-
-Draw::Draws VArc::getMode() const{
-    return mode;
-}
-
-void VArc::setMode(const Draw::Draws &value){
-    mode = value;
-}
-
-qint64 VArc::getIdObject() const{
-    return idObject;
-}
-
-void VArc::setIdObject(const qint64 &value){
-    idObject = value;
-}
diff --git a/geometry/varc.h b/geometry/varc.h
index 7b8a99fc5..ac436da4b 100644
--- a/geometry/varc.h
+++ b/geometry/varc.h
@@ -23,7 +23,6 @@
 #define VARC_H
 
 #include "vspline.h"
-#include <QCoreApplication>
 
 /**
  * @brief VArc клас, що реалізує дугу. Дуга розраховується за годиниковою стрілкою.
@@ -51,56 +50,55 @@ public:
      * @brief GetF1 повертає початковий кут дуги.
      * @return повертає кут в градусах.
      */
-    QString      GetFormulaF1 () const;
-    qreal        GetF1 () const;
+    inline QString     GetFormulaF1 () const {return formulaF1;}
+    inline qreal       GetF1 () const {return f1;}
     /**
      * @brief GetF2 повертає кінцевий кут дуги.
      * @return повертає кут в градусах.
      */
-    QString      GetFormulaF2 () const;\
-    qreal        GetF2 () const;
+    inline QString     GetFormulaF2 () const {return formulaF2;}
+    inline qreal       GetF2 () const {return f2;}
     /**
      * @brief GetLength повертає довжину дуги.
      * @return повертає довжину дуги.
      */
-    qreal        GetLength () const;
+    inline qreal       GetLength () const {return M_PI * radius/180 * (f2-f1);}
     /**
      * @brief GetRadius повертає радіус дуги.
      * @return повертає радіус дуги.
      */
-    QString      GetFormulaRadius () const;
-    qreal        GetRadius () const;
+    inline QString     GetFormulaRadius () const {return formulaRadius;}
+    inline qreal       GetRadius () const {return radius;}
     /**
      * @brief GetCenter повертає точку центра дуги.
      * @return повертає точку центра дуги.
      */
-    qint64      GetCenter () const;
-    QPointF GetCenterPoint() const;
+    inline qint64      GetCenter () const {return center;}
+    QPointF            GetCenterPoint() const;
     /**
      * @brief GetP1 повертає першу точку з якої починається дуга.
      * @return точку початку дуги.
      */
-    QPointF      GetP1 () const;
+    QPointF            GetP1 () const;
     /**
      * @brief GetP2 повертає другу точку в якій закінчується дуга.
      * @return точку кінця дуги.
      */
-    QPointF      GetP2 () const;
+    QPointF            GetP2 () const;
     const QHash<qint64, VPointF> GetDataPoints() const;
     /**
      * @brief GetPath будує шлях по даній дузі.
      * @return повертає шлях.
      */
-    QPainterPath GetPath() const;
-    qreal AngleArc()const;
-    qint32 NumberSplOfArc () const;
-    QVector<QPointF> GetPoints () const;
-    QVector<QPointF> SplOfArc( qint32 number ) const;
-    Draw::Draws getMode() const;
-    void setMode(const Draw::Draws &value);
-    qint64 getIdObject() const;
-    void setIdObject(const qint64 &value);
-
+    QPainterPath       GetPath() const;
+    qreal              AngleArc() const;
+    qint32             NumberSplOfArc () const;
+    QVector<QPointF>   GetPoints () const;
+    QVector<QPointF>   SplOfArc( qint32 number ) const;
+    inline Draw::Draws getMode() const {return mode;}
+    inline void        setMode(const Draw::Draws &value) {mode = value;}
+    inline qint64      getIdObject() const {return idObject;}
+    inline void        setIdObject(const qint64 &value) {idObject = value;}
 private:
     /**
      * @brief f1 початковий кут в градусах
diff --git a/geometry/vdetail.cpp b/geometry/vdetail.cpp
index 7e7fdf0c2..9003d35e5 100644
--- a/geometry/vdetail.cpp
+++ b/geometry/vdetail.cpp
@@ -45,10 +45,6 @@ VDetail &VDetail::operator =(const VDetail &detail){
     return *this;
 }
 
-void VDetail::append(const VNodeDetail &node){
-    nodes.append(node);
-}
-
 void VDetail::Clear(){
     nodes.clear();
     name.clear();
@@ -59,10 +55,6 @@ void VDetail::Clear(){
     width = 10;
 }
 
-qint32 VDetail::CountNode() const{
-    return nodes.size();
-}
-
 bool VDetail::Containes(const qint64 &id) const{
     for(qint32 i = 0; i < nodes.size(); ++i){
         VNodeDetail node = nodes[i];
@@ -77,58 +69,3 @@ VNodeDetail &VDetail::operator [](int indx){
     return nodes[indx];
 }
 
-qreal VDetail::getMy() const{
-    return my;
-}
-
-void VDetail::setMy(const qreal &value){
-    my = value;
-}
-
-qreal VDetail::getMx() const{
-    return mx;
-}
-
-void VDetail::setMx(const qreal &value){
-    mx = value;
-}
-
-QString VDetail::getName() const{
-    return name;
-}
-
-void VDetail::setName(const QString &value){
-    name = value;
-}
-
-qreal VDetail::getWidth() const{
-    return width;
-}
-
-void VDetail::setWidth(const qreal &value){
-    width = value;
-}
-
-bool VDetail::getClosed() const{
-    return closed;
-}
-
-void VDetail::setClosed(bool value){
-    closed = value;
-}
-
-bool VDetail::getSupplement() const{
-    return supplement;
-}
-
-void VDetail::setSupplement(bool value){
-    supplement = value;
-}
-
-QVector<VNodeDetail> VDetail::getNodes() const{
-    return nodes;
-}
-
-void VDetail::setNodes(const QVector<VNodeDetail> &value){
-    nodes = value;
-}
diff --git a/geometry/vdetail.h b/geometry/vdetail.h
index 5372e219a..cb31ceee8 100644
--- a/geometry/vdetail.h
+++ b/geometry/vdetail.h
@@ -23,9 +23,6 @@
 #define VDETAIL_H
 
 #include "vnodedetail.h"
-#include <QVector>
-#include <QString>
-#include <QPainterPath>
 
 namespace Detail {
     enum Contour { OpenContour, CloseContour };
@@ -39,37 +36,37 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(Detail::Equidistants)
 
 class VDetail{
 public:
-            VDetail();
-            VDetail(const QString &name, const QVector<VNodeDetail> &nodes);
-            VDetail(const VDetail &detail);
-            VDetail &operator=(const VDetail &detail);
-    void    append(const VNodeDetail &node);
-    void    Clear();
-    qint32  CountNode() const;
-    bool    Containes(const qint64 &id)const;
-    VNodeDetail & operator[](int indx);
-    QString getName() const;
-    void    setName(const QString &value);
-    qreal   getMx() const;
-    void    setMx(const qreal &value);
-    qreal   getMy() const;
-    void    setMy(const qreal &value);
-    bool    getSupplement() const;
-    void    setSupplement(bool value);
-    bool    getClosed() const;
-    void    setClosed(bool value);
-    qreal   getWidth() const;
-    void    setWidth(const qreal &value);
-    QVector<VNodeDetail> getNodes() const;
-    void    setNodes(const QVector<VNodeDetail> &value);
+                   VDetail();
+                   VDetail(const QString &name, const QVector<VNodeDetail> &nodes);
+                   VDetail(const VDetail &detail);
+                   VDetail &operator=(const VDetail &detail);
+    inline void    append(const VNodeDetail &node) {nodes.append(node);}
+    void           Clear();
+    inline qint32  CountNode() const {return nodes.size();}
+    bool           Containes(const qint64 &id)const;
+    VNodeDetail &  operator[](int indx);
+    inline QString getName() const {return name;}
+    inline void    setName(const QString &value) {name = value;}
+    inline qreal   getMx() const {return mx;}
+    inline void    setMx(const qreal &value) {mx = value;}
+    inline qreal   getMy() const {return my;}
+    inline void    setMy(const qreal &value) {my = value;}
+    inline bool    getSupplement() const {return supplement;}
+    inline void    setSupplement(bool value) {supplement = value;}
+    inline bool    getClosed() const {return closed;}
+    inline void    setClosed(bool value) {closed = value;}
+    inline qreal   getWidth() const {return width;}
+    inline void    setWidth(const qreal &value) {width = value;}
+    inline QVector<VNodeDetail> getNodes() const {return nodes;}
+    inline void    setNodes(const QVector<VNodeDetail> &value) {nodes = value;}
 private:
     QVector<VNodeDetail> nodes;
-    QString name;
-    qreal   mx;
-    qreal   my;
-    bool    supplement;
-    bool    closed;
-    qreal   width;
+    QString        name;
+    qreal          mx;
+    qreal          my;
+    bool           supplement;
+    bool           closed;
+    qreal          width;
 };
 
 #endif // VDETAIL_H
diff --git a/geometry/vnodedetail.cpp b/geometry/vnodedetail.cpp
index b25c28d92..50a5b5424 100644
--- a/geometry/vnodedetail.cpp
+++ b/geometry/vnodedetail.cpp
@@ -43,51 +43,3 @@ VNodeDetail &VNodeDetail::operator =(const VNodeDetail &node){
     my = node.getMy();
     return *this;
 }
-
-Tool::Tools VNodeDetail::getTypeTool() const{
-    return typeTool;
-}
-
-void VNodeDetail::setTypeTool(const Tool::Tools &value){
-    typeTool = value;
-}
-
-qint64 VNodeDetail::getId() const{
-    return id;
-}
-
-void VNodeDetail::setId(const qint64 &value){
-    id = value;
-}
-
-Draw::Draws VNodeDetail::getMode() const{
-    return mode;
-}
-
-void VNodeDetail::setMode(const Draw::Draws &value){
-    mode = value;
-}
-
-NodeDetail::NodeDetails VNodeDetail::getTypeNode() const{
-    return typeNode;
-}
-
-void VNodeDetail::setTypeNode(const NodeDetail::NodeDetails &value){
-    typeNode = value;
-}
-
-qreal VNodeDetail::getMy() const{
-    return my;
-}
-
-void VNodeDetail::setMy(const qreal &value){
-    my = value;
-}
-
-qreal VNodeDetail::getMx() const{
-    return mx;
-}
-
-void VNodeDetail::setMx(const qreal &value){
-    mx = value;
-}
diff --git a/geometry/vnodedetail.h b/geometry/vnodedetail.h
index 04359f9da..d28068ba2 100644
--- a/geometry/vnodedetail.h
+++ b/geometry/vnodedetail.h
@@ -33,30 +33,30 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(NodeDetail::NodeDetails)
 
 class VNodeDetail{
 public:
-                VNodeDetail();
-                VNodeDetail(qint64 id, Tool::Tools typeTool, Draw::Draws mode, NodeDetail::NodeDetails typeNode,
-                            qreal mx = 0, qreal my = 0);
-                VNodeDetail(const VNodeDetail &node);
-                VNodeDetail &operator=(const VNodeDetail &node);
-    qint64      getId() const;
-    void        setId(const qint64 &value);
-    Tool::Tools getTypeTool() const;
-    void        setTypeTool(const Tool::Tools &value);
-    Draw::Draws getMode() const;
-    void        setMode(const Draw::Draws &value);
-    NodeDetail::NodeDetails getTypeNode() const;
-    void        setTypeNode(const NodeDetail::NodeDetails &value);
-    qreal       getMx() const;
-    void        setMx(const qreal &value);
-    qreal       getMy() const;
-    void        setMy(const qreal &value);
+                  VNodeDetail();
+                  VNodeDetail(qint64 id, Tool::Tools typeTool, Draw::Draws mode, NodeDetail::NodeDetails typeNode,
+                              qreal mx = 0, qreal my = 0);
+                  VNodeDetail(const VNodeDetail &node);
+                  VNodeDetail &operator=(const VNodeDetail &node);
+    inline qint64 getId() const {return id;}
+    inline void   setId(const qint64 &value) {id = value;}
+    inline Tool::Tools getTypeTool() const {return typeTool;}
+    inline void   setTypeTool(const Tool::Tools &value) {typeTool = value;}
+    inline Draw::Draws getMode() const {return mode;}
+    inline void   setMode(const Draw::Draws &value) {mode = value;}
+    inline NodeDetail::NodeDetails getTypeNode() const {return typeNode;}
+    inline void   setTypeNode(const NodeDetail::NodeDetails &value) {typeNode = value;}
+    inline qreal  getMx() const {return mx;}
+    inline void   setMx(const qreal &value) {mx = value;}
+    inline qreal  getMy() const {return my;}
+    inline void   setMy(const qreal &value) {my = value;}
 private:
-    qint64      id;
-    Tool::Tools typeTool;
-    Draw::Draws mode;
+    qint64        id;
+    Tool::Tools   typeTool;
+    Draw::Draws   mode;
     NodeDetail::NodeDetails typeNode;
-    qreal       mx;
-    qreal       my;
+    qreal         mx;
+    qreal         my;
 };
 
 Q_DECLARE_METATYPE(VNodeDetail)
diff --git a/geometry/vspline.cpp b/geometry/vspline.cpp
index 674980add..f15abbde9 100644
--- a/geometry/vspline.cpp
+++ b/geometry/vspline.cpp
@@ -20,7 +20,6 @@
  ****************************************************************************/
 
 #include "vspline.h"
-#include <QDebug>
 
 VSpline::VSpline():p1(0), p2(QPointF()), p3(QPointF()), p4(0), angle1(0), angle2(0), kAsm1(1), kAsm2(1),
     kCurve(1), points(QHash<qint64, VPointF>()), mode(Draw::Calculation), idObject(0){
@@ -33,8 +32,8 @@ VSpline::VSpline ( const VSpline & spline ):p1(spline.GetP1 ()), p2(spline.GetP2
 }
 
 VSpline::VSpline (const QHash<qint64, VPointF> *points, qint64 p1, qint64 p4, qreal angle1, qreal angle2,
-                  qreal kAsm1, qreal kAsm2 , qreal kCurve, Draw::Draws mode, qint64 idObject):p1(p1), p2(QPointF()), p3(QPointF()),
-    p4(p4), angle1(angle1), angle2(angle2), kAsm1(kAsm1), kAsm2(kAsm2), kCurve(kCurve), points(*points),
+                  qreal kAsm1, qreal kAsm2 , qreal kCurve, Draw::Draws mode, qint64 idObject):p1(p1), p2(QPointF()),
+    p3(QPointF()), p4(p4), angle1(angle1), angle2(angle2), kAsm1(kAsm1), kAsm2(kAsm2), kCurve(kCurve), points(*points),
     mode(mode), idObject(idObject){
     ModifiSpl ( p1, p4, angle1, angle2, kAsm1, kAsm2, kCurve );
 }
@@ -124,10 +123,6 @@ void VSpline::ModifiSpl (qint64 p1, QPointF p2, QPointF p3, qint64 p4, qreal kCu
 //    p4 = QPointF(p4.x()+mx, p4.y()+my);
 //}
 
-qint64 VSpline::GetP1 () const{
-    return p1;
-}
-
 VPointF VSpline::GetPointP1() const{
     if(points.contains(p1)){
         return points.value(p1);
@@ -138,18 +133,6 @@ VPointF VSpline::GetPointP1() const{
     return VPointF();
 }
 
-QPointF VSpline::GetP2 () const{
-    return p2;
-}
-
-QPointF VSpline::GetP3 () const{
-    return p3;
-}
-
-qint64 VSpline::GetP4() const{
-    return p4;
-}
-
 VPointF VSpline::GetPointP4() const{
     if(points.contains(p4)){
         return points.value(p4);
@@ -160,14 +143,6 @@ VPointF VSpline::GetPointP4() const{
     return VPointF();
 }
 
-qreal VSpline::GetAngle1() const{
-    return angle1;
-}
-
-qreal VSpline::GetAngle2 () const{
-    return angle2;
-}
-
 qreal VSpline::GetLength () const{
     return LengthBezier ( GetPointP1().toQPointF(), this->p2, this->p3, GetPointP4().toQPointF());
 }
@@ -178,22 +153,6 @@ QString VSpline::GetName() const{
     return QString("Spl_%1_%2").arg(first.name(), second.name());
 }
 
-qreal VSpline::GetKasm1() const{
-    return kAsm1;
-}
-
-qreal VSpline::GetKasm2() const{
-    return kAsm2;
-}
-
-qreal VSpline::GetKcurve() const{
-    return kCurve;
-}
-
-const QHash<qint64, VPointF> VSpline::GetDataPoints() const{
-    return points;
-}
-
 QLineF::IntersectType VSpline::CrossingSplLine ( const QLineF &line, QPointF *intersectionPoint ) const{
     QVector<qreal> px;
     QVector<qreal> py;
@@ -737,14 +696,6 @@ qint32 VSpline::Cubic(qreal *x, qreal a, qreal b, qreal c){
 //    this->ModifiSpl(P1, P2, P3, P4);
 //}
 
-Draw::Draws VSpline::getMode() const{
-    return mode;
-}
-
-void VSpline::setMode(const Draw::Draws &value){
-    mode = value;
-}
-
 QVector<QPointF> VSpline::SplinePoints(QPointF p1, QPointF p4, qreal angle1, qreal angle2, qreal kAsm1,
                                        qreal kAsm2, qreal kCurve){
     QLineF p1pX(p1.x(), p1.y(), p1.x() + 100, p1.y());
@@ -761,14 +712,6 @@ QVector<QPointF> VSpline::SplinePoints(QPointF p1, QPointF p4, qreal angle1, qre
     return GetPoints(p1, p2, p3, p4);
 }
 
-qint64 VSpline::getIdObject() const{
-    return idObject;
-}
-
-void VSpline::setIdObject(const qint64 &value){
-    idObject = value;
-}
-
 VSpline &VSpline::operator =(const VSpline &spline){
     this->p1 = spline.GetP1 ();
     this->p2 = spline.GetP2 ();
diff --git a/geometry/vspline.h b/geometry/vspline.h
index d87260421..b91d0b88a 100644
--- a/geometry/vspline.h
+++ b/geometry/vspline.h
@@ -22,24 +22,21 @@
 #ifndef VSPLINE_H
 #define VSPLINE_H
 
-#define M_2PI   6.28318530717958647692528676655900576
+#include <container/vpointf.h>
 
-#include <QPainterPath>
-#include <QVector>
-#include <QHash>
-#include "container/vpointf.h"
+#define M_2PI   6.28318530717958647692528676655900576
 
 /**
  * @brief VSpline клас, що реалізує сплайн.
  */
 class VSpline{
 public:
-                    VSpline();
+                   VSpline();
                      /**
                       * @brief VSpline конструктор.
                       * @param spline сплайн з якого копіюємо.
                       */
-                     VSpline (const VSpline &spline );
+                   VSpline (const VSpline &spline );
                      /**
                       * @brief VSpline конструктор.
                       * @param p1 початкова точка сплайна.
@@ -50,9 +47,9 @@ public:
                       * @param kAsm1 коефіцієнт довжини першої напрямної.
                       * @param kAsm2 коефіцієнт довжини другої напрямної.
                       */
-                     VSpline (const QHash<qint64, VPointF> *points, qint64 p1, qint64 p4, qreal angle1,
-                              qreal angle2, qreal kAsm1, qreal kAsm2, qreal kCurve,
-                              Draw::Draws mode = Draw::Calculation, qint64 idObject = 0);
+                   VSpline (const QHash<qint64, VPointF> *points, qint64 p1, qint64 p4, qreal angle1, qreal angle2,
+                            qreal kAsm1, qreal kAsm2, qreal kCurve, Draw::Draws mode = Draw::Calculation,
+                            qint64 idObject = 0);
                      /**
                       * @brief VSpline конструктор.
                       * @param p1 початкова точка сплайну.
@@ -60,9 +57,8 @@ public:
                       * @param p3 друга контролююча точка сплайну.
                       * @param p4 кінцева точка сплайну.
                       */
-                     VSpline (const QHash<qint64, VPointF> *points, qint64 p1, QPointF p2, QPointF p3,
-                              qint64 p4, qreal kCurve, Draw::Draws mode = Draw::Calculation,
-                              qint64 idObject = 0);
+                   VSpline (const QHash<qint64, VPointF> *points, qint64 p1, QPointF p2, QPointF p3, qint64 p4,
+                            qreal kCurve, Draw::Draws mode = Draw::Calculation, qint64 idObject = 0);
     /**
      * @brief ModifiSpl модифікує сплайн.
      * @param p1 початкова точка сплайну.
@@ -73,7 +69,7 @@ public:
      * @param kAsm1 коефіцієнт довжини першої напрямної.
      * @param kAsm2 коефіцієнт довжини другої напрямної.
      */
-    void             ModifiSpl ( qint64 p1, qint64 p4, qreal angle1, qreal angle2, qreal kAsm1, qreal kAsm2,
+    void           ModifiSpl ( qint64 p1, qint64 p4, qreal angle1, qreal angle2, qreal kAsm1, qreal kAsm2,
                                  qreal kCurve);
     /**
      * @brief ModifiSpl модифікує сплайн.
@@ -82,61 +78,61 @@ public:
      * @param p3 друга контролююча точка сплайну.
      * @param p4 кінцева точка сплайну.
      */
-    void             ModifiSpl (qint64 p1, QPointF p2, QPointF p3, qint64 p4, qreal kCurve);
+    void           ModifiSpl (qint64 p1, QPointF p2, QPointF p3, qint64 p4, qreal kCurve);
     /**
      * @brief RotationSpl поворот сплайна навколо точки на кут в градусах проти годиникової стрілки.
      * @param pRotate точка навколо якої повертаємо.
      * @param angle кут в градусах.
      */
-//    void             RotationSpl ( QPointF pRotate, qreal angle );
+//    void         RotationSpl ( QPointF pRotate, qreal angle );
     /**
      * @brief BiasSpl зміщує сплайн.
      * @param mx зміщення по х координаті.
      * @param my зміщення по у координаті.
      */
-//    void             BiasSpl ( qreal mx, qreal my );
+//    void         BiasSpl ( qreal mx, qreal my );
     /**
      * @brief GetP1 повертає першу точку сплайну.
      * @return перша точка сплайну.
      */
-    qint64           GetP1 () const;
-    VPointF          GetPointP1() const;
+    qint64         GetP1 () const {return p1;}
+    VPointF        GetPointP1() const;
     /**
      * @brief GetP2 повертує першу контрольну точку сплайну.
      * @return перша контрольна точка сплайну.
      */
-    QPointF          GetP2 () const;
+    inline QPointF GetP2 () const {return p2;}
     /**
      * @brief GetP3 повертає другу контрольну точку сплайну.
      * @return друга контрольна точка сплайну.
      */
-    QPointF          GetP3 () const;
+    inline QPointF GetP3 () const {return p3;}
     /**
      * @brief GetP4 повертає останню точку сплайну.
      * @return остання точка сплайну.
      */
-    qint64           GetP4 () const;
-    VPointF          GetPointP4 () const;
+    inline qint64  GetP4 () const {return p4;}
+    VPointF        GetPointP4 () const;
     /**
      * @brief GetAngle1 повертає кут першої напрямної.
      * @return кут в градусах.
      */
-    qreal            GetAngle1 () const;
+    inline qreal   GetAngle1 () const {return angle1;}
     /**
      * @brief GetAngle2 повертає кут другої напрямної.
      * @return кут в градусах.
      */
-    qreal            GetAngle2() const;
+    inline qreal   GetAngle2() const {return angle2;}
     /**
      * @brief GetLength повертає довжину сплайну.
      * @return довжина сплайну.
      */
-    qreal            GetLength () const;
-    QString          GetName () const;
-    qreal            GetKasm1() const;
-    qreal            GetKasm2() const;
-    qreal            GetKcurve() const;
-    const QHash<qint64, VPointF> GetDataPoints() const;
+    qreal          GetLength () const;
+    QString        GetName () const;
+    inline qreal   GetKasm1() const {return kAsm1;}
+    inline qreal   GetKasm2() const {return kAsm2;}
+    inline qreal   GetKcurve() const {return kCurve;}
+    inline const QHash<qint64, VPointF> GetDataPoints() const {return points;}
     /**
      * @brief CrossingSplLine перевіряє перетин сплайну з лінією.
      * @param line лінія з якою перевіряється перетин.
@@ -150,20 +146,20 @@ public:
      * @param curFir перший сплайн.
      * @param curSec другий сплайн.
      */
-//    void             CutSpline ( qreal length, VSpline* curFir, VSpline* curSec ) const;
+//    void         CutSpline ( qreal length, VSpline* curFir, VSpline* curSec ) const;
     /**
      * @brief CutSpline розрізає сплайн.
      * @param point точка що ділить сплайн.
      * @param curFir перший сплайн.
      * @param curSec другий сплайн.
      */
-//    void             CutSpline (QPointF point, VSpline* curFir, VSpline* curSec ) const;
+//    void         CutSpline (QPointF point, VSpline* curFir, VSpline* curSec ) const;
     /**
      * @brief PutAlongSpl розміщає точку на сплайні.
      * @param moveP точка яка розміщується на сплайні.
      * @param move довжина від початку сплайну.
      */
-//    void             PutAlongSpl ( QPointF &moveP, qreal move ) const;
+//    void         PutAlongSpl ( QPointF &moveP, qreal move ) const;
     /**
      * @brief GetPoints повертає точки з яких складається сплайн.
      * @return список точок.
@@ -173,19 +169,19 @@ public:
      * @brief GetPath повертає шлях сплайну.
      * @return шлях.
      */
-    QPainterPath     GetPath() const;
+    QPainterPath   GetPath() const;
     /**
      * @brief Mirror вертикальне дзеркалення сплайну відносно точки.
      * @param Pmirror точка відносно якої відбувається вертикальне дзеркалення сплайну.
      */
-//    void             Mirror(const QPointF Pmirror);
-    Draw::Draws getMode() const;
-    void setMode(const Draw::Draws &value);
-    static QVector<QPointF> SplinePoints(QPointF p1, QPointF p4, qreal angle1,
-                                         qreal angle2, qreal kAsm1, qreal kAsm2, qreal kCurve);
-    qint64 getIdObject() const;
-    void setIdObject(const qint64 &value);
-    VSpline &operator=(const VSpline &spl);
+//    void         Mirror(const QPointF Pmirror);
+    inline Draw::Draws getMode() const {return mode;}
+    inline void    setMode(const Draw::Draws &value) {mode = value;}
+    static QVector<QPointF> SplinePoints(QPointF p1, QPointF p4, qreal angle1, qreal angle2, qreal kAsm1, qreal kAsm2,
+                                         qreal kCurve);
+    inline qint64  getIdObject() const {return idObject;}
+    inline void    setIdObject(const qint64 &value) {idObject = value;}
+    VSpline        &operator=(const VSpline &spl);
 protected:
     /**
      * @brief GetPoints повертає точки з яких складається сплайн.
@@ -200,33 +196,33 @@ private:
     /**
      * @brief p1 початкова точка сплайну
      */
-    qint64          p1;			// перша точка
+    qint64         p1;			// перша точка
     /**
      * @brief p2 перша контрольна точка сплайну.
      */
-    QPointF          p2;			// друга точка
+    QPointF        p2;			// друга точка
     /**
      * @brief p3 друга контрольна точка сплайну.
      */
-    QPointF          p3;			// третя точка
+    QPointF        p3;			// третя точка
     /**
      * @brief p4 кінцеві точка сплайну.
      */
-    qint64          p4;			// четверта точка
+    qint64         p4;			// четверта точка
     /**
      * @brief angle1 кут в градусах першої напрямної.
      */
-    qreal            angle1;		// кут нахилу дотичної в першій точці
+    qreal          angle1;		// кут нахилу дотичної в першій точці
     /**
      * @brief angle2 кут в градусах другої напрямної.
      */
-    qreal            angle2;		// кут нахилу дотичної в другій точці
-    qreal kAsm1;
-    qreal kAsm2;
-    qreal kCurve;
+    qreal          angle2;		// кут нахилу дотичної в другій точці
+    qreal          kAsm1;
+    qreal          kAsm2;
+    qreal          kCurve;
     QHash<qint64, VPointF> points;
-    Draw::Draws mode;
-    qint64 idObject;
+    Draw::Draws    mode;
+    qint64         idObject;
     /**
      * @brief LengthBezier повертає дожину сплайну за його чотирьма точками.
      * @param p1 початкова точка сплайну.
@@ -235,7 +231,7 @@ private:
      * @param p4 кінцева точка сплайну.
      * @return дожина сплайну.
      */
-    qreal            LengthBezier ( QPointF p1, QPointF p2, QPointF p3, QPointF p4 ) const;
+    qreal          LengthBezier ( QPointF p1, QPointF p2, QPointF p3, QPointF p4 ) const;
     /**
      * @brief PointBezier_r знаходить точки сплайну по його чотирьом точках.
      * @param x1 х координата першої точки сплайну.
@@ -250,9 +246,8 @@ private:
      * @param px список х координат точок сплайну.
      * @param py список у коодринат сплайну.
      */
-    static void             PointBezier_r ( qreal x1, qreal y1, qreal x2, qreal y2,
-                                     qreal x3, qreal y3, qreal x4, qreal y4,
-                                     qint16 level, QVector<qreal> &px, QVector<qreal> &py);
+    static void    PointBezier_r ( qreal x1, qreal y1, qreal x2, qreal y2, qreal x3, qreal y3, qreal x4, qreal y4,
+                                  qint16 level, QVector<qreal> &px, QVector<qreal> &py);
     /**
      * @brief CalcSqDistance розраховує довжину між точками.
      * @param x1 х координата першої точки.
@@ -261,7 +256,7 @@ private:
      * @param y2 у координата другої точки.
      * @return довжину.
      */
-    static qreal            CalcSqDistance ( qreal x1, qreal y1, qreal x2, qreal y2);
+    static qreal   CalcSqDistance ( qreal x1, qreal y1, qreal x2, qreal y2);
     /**
      * @brief Cubic знаходить розв'язок кубічного рівняння.
      * @param x коефіцієнт.
@@ -270,7 +265,7 @@ private:
      * @param c коефіцієнт.
      * @return повертає корені рівняння.
      */
-    static qint32           Cubic(qreal *x, qreal a, qreal b, qreal c);
+    static qint32  Cubic(qreal *x, qreal a, qreal b, qreal c);
     /**
      * @brief calc_t знаходить параметр t якому відповідає точка на сплайні.
      * @param curve_coord1 координата Х або У кривої.
@@ -280,14 +275,14 @@ private:
      * @param point_coord координата Х або У точки на кривій.
      * @return
      */
-//    static qreal            calc_t (qreal curve_coord1, qreal curve_coord2, qreal curve_coord3,
-//                                    qreal curve_coord4, qreal point_coord)const;
+//    static qreal calc_t (qreal curve_coord1, qreal curve_coord2, qreal curve_coord3, qreal curve_coord4,
+//                         qreal point_coord)const;
     /**
      * @brief param_t  знаходить підходяще значення параметра t якому відповідає точка на сплайні
      * @param pBt точка для якої шукається значення параметра t.
      * @return підходяще значення t.
      */
-//    qreal            param_t (QPointF pBt)const;
+//    qreal        param_t (QPointF pBt)const;
 };
 
 #endif // VSPLINE_H
diff --git a/geometry/vsplinepath.cpp b/geometry/vsplinepath.cpp
index bd0a5a8fe..e58269751 100644
--- a/geometry/vsplinepath.cpp
+++ b/geometry/vsplinepath.cpp
@@ -20,7 +20,7 @@
  ****************************************************************************/
 
 #include "vsplinepath.h"
-#include "exception/vexception.h"
+#include <exception/vexception.h>
 
 VSplinePath::VSplinePath(): path(QVector<VSplinePoint>()), kCurve(1), mode(Draw::Calculation),
     points(QHash<qint64, VPointF>()), idObject(0){
@@ -35,14 +35,6 @@ VSplinePath::VSplinePath(const VSplinePath &splPath): path(*splPath.GetPoint()),
     idObject(splPath.getIdObject()){
 }
 
-Draw::Draws VSplinePath::getMode() const{
-    return mode;
-}
-
-void VSplinePath::setMode(const Draw::Draws &value){
-    mode = value;
-}
-
 void VSplinePath::append(VSplinePoint point){
     path.append(point);
 }
@@ -55,10 +47,6 @@ qint32 VSplinePath::Count() const{
     }
 }
 
-qint32 VSplinePath::CountPoint() const{
-    return path.size();
-}
-
 VSpline VSplinePath::GetSpline(qint32 index) const{
     if(Count()<1){
         throw VException(tr("Not enough points to create the spline."));
@@ -94,10 +82,6 @@ QVector<QPointF> VSplinePath::GetPathPoints() const{
     return pathPoints;
 }
 
-QVector<VSplinePoint> VSplinePath::GetSplinePath() const{
-    return path;
-}
-
 qreal VSplinePath::GetLength() const{
     qreal length = 0;
     for(qint32 i = 1; i <= Count(); ++i){
@@ -108,10 +92,6 @@ qreal VSplinePath::GetLength() const{
     return length;
 }
 
-QHash<qint64, VPointF> VSplinePath::GetDataPoints() const{
-    return points;
-}
-
 void VSplinePath::UpdatePoint(qint32 indexSpline, SplinePoint::Position pos, VSplinePoint point){
     if(indexSpline < 1 || indexSpline > Count()){
         throw VException(tr("This spline is not exist."));
@@ -134,22 +114,6 @@ VSplinePoint VSplinePath::GetSplinePoint(qint32 indexSpline, SplinePoint::Positi
     }
 }
 
-void VSplinePath::Clear(){
-    path.clear();
-}
-
-qreal VSplinePath::getKCurve() const{
-    return kCurve;
-}
-
-void VSplinePath::setKCurve(const qreal &value){
-    kCurve = value;
-}
-
-const QVector<VSplinePoint> *VSplinePath::GetPoint() const{
-    return &path;
-}
-
 VSplinePath &VSplinePath::operator =(const VSplinePath &path){
     this->path = path.GetSplinePath();
     this->kCurve = path.getKCurve();
@@ -162,11 +126,3 @@ VSplinePath &VSplinePath::operator =(const VSplinePath &path){
 VSplinePoint & VSplinePath::operator[](int indx){
     return path[indx];
 }
-
-qint64 VSplinePath::getIdObject() const{
-    return idObject;
-}
-
-void VSplinePath::setIdObject(const qint64 &value){
-    idObject = value;
-}
diff --git a/geometry/vsplinepath.h b/geometry/vsplinepath.h
index a00be2c9b..7a8ba8daa 100644
--- a/geometry/vsplinepath.h
+++ b/geometry/vsplinepath.h
@@ -23,8 +23,9 @@
 #define VSPLINEPATH_H
 
 #include "vsplinepoint.h"
+#include <container/vpointf.h>
 #include "vspline.h"
-#include <QCoreApplication>
+#include <QApplication>
 
 namespace SplinePoint{
 enum Position { FirstPoint, LastPoint };
@@ -41,52 +42,52 @@ public:
                           /**
                            * @brief VSplinePath конструктор по замовчуванню.
                            */
-                          VSplinePath();
+                  VSplinePath();
                           /**
                            * @brief VSplinePath конструктор по замовчуванню.
                            */
-                          VSplinePath(const QHash<qint64, VPointF> *points, qreal kCurve = 1,
-                                      Draw::Draws mode = Draw::Calculation, qint64 idObject = 0);
-                          VSplinePath(const VSplinePath& splPath);
+                  VSplinePath(const QHash<qint64, VPointF> *points, qreal kCurve = 1,
+                              Draw::Draws mode = Draw::Calculation, qint64 idObject = 0);
+                  VSplinePath(const VSplinePath& splPath);
     /**
      * @brief append додає точку сплайну до шляху.
      * @param point точка.
      */
-    void                  append(VSplinePoint point);
-    qint32                Count() const;
-    qint32                CountPoint() const;
-    VSpline               GetSpline(qint32 index) const;
-    QPainterPath          GetPath() const;
-    QVector<QPointF>      GetPathPoints() const;
-    QVector<VSplinePoint> GetSplinePath() const;
-    qreal                 GetLength() const;
-    QHash<qint64, VPointF> GetDataPoints() const;
-    void                  UpdatePoint(qint32 indexSpline, SplinePoint::Position pos, VSplinePoint point);
-    VSplinePoint          GetSplinePoint(qint32 indexSpline, SplinePoint::Position pos) const;
+    void          append(VSplinePoint point);
+    qint32        Count() const;
+    inline qint32 CountPoint() const {return path.size();}
+    VSpline       GetSpline(qint32 index) const;
+    QPainterPath  GetPath() const;
+    QVector<QPointF> GetPathPoints() const;
+    inline QVector<VSplinePoint> GetSplinePath() const {return path;}
+    qreal         GetLength() const;
+    inline QHash<qint64, VPointF> GetDataPoints() const {return points;}
+    void          UpdatePoint(qint32 indexSpline, SplinePoint::Position pos, VSplinePoint point);
+    VSplinePoint  GetSplinePoint(qint32 indexSpline, SplinePoint::Position pos) const;
     /**
      * @brief Clear очищає шлях сплайнів.
      */
-    void                  Clear();
-    qreal getKCurve() const;
-    void setKCurve(const qreal &value);
-    const QVector<VSplinePoint> *GetPoint() const;
-    VSplinePath& operator=(const VSplinePath &path);
-    VSplinePoint & operator[](int indx);
-    Draw::Draws getMode() const;
-    void setMode(const Draw::Draws &value);
+    inline void   Clear() {path.clear();}
+    inline qreal  getKCurve() const {return kCurve;}
+    inline void   setKCurve(const qreal &value) {kCurve = value;}
+    inline const  QVector<VSplinePoint> *GetPoint() const {return &path;}
+    VSplinePath   &operator=(const VSplinePath &path);
+    VSplinePoint  &operator[](int indx);
+    inline Draw::Draws getMode() const {return mode;}
+    inline void   setMode(const Draw::Draws &value) {mode = value;}
 
-    qint64 getIdObject() const;
-    void setIdObject(const qint64 &value);
+    inline qint64 getIdObject() const {return idObject;}
+    inline void   setIdObject(const qint64 &value) {idObject = value;}
 
 protected:
     /**
      * @brief path вектор з точок сплайна.
      */
     QVector<VSplinePoint> path;
-    qreal kCurve;
-    Draw::Draws mode;
+    qreal         kCurve;
+    Draw::Draws   mode;
     QHash<qint64, VPointF> points;
-    qint64 idObject;
+    qint64        idObject;
 };
 
 #endif // VSPLINEPATH_H
diff --git a/geometry/vsplinepoint.cpp b/geometry/vsplinepoint.cpp
index 6409eb5d5..ab071e509 100644
--- a/geometry/vsplinepoint.cpp
+++ b/geometry/vsplinepoint.cpp
@@ -32,41 +32,8 @@ VSplinePoint::VSplinePoint(const VSplinePoint &point):pSpline(point.P()), angle(
     kAsm1(point.KAsm1()), kAsm2(point.KAsm2()){
 }
 
-VSplinePoint::~VSplinePoint(){
-}
 
-qint64 VSplinePoint::P() const{
-    return pSpline;
-}
 
-void VSplinePoint::SetP(const qint64 &value){
-    pSpline = value;
-}
 
-qreal VSplinePoint::Angle1() const{
-    return angle+180;
-}
 
-void VSplinePoint::SetAngle(const qreal &value){
-    angle = value;
-}
 
-qreal VSplinePoint::Angle2() const{
-    return angle;
-}
-
-qreal VSplinePoint::KAsm1() const{
-    return kAsm1;
-}
-
-void VSplinePoint::SetKAsm1(const qreal &value){
-    kAsm1 = value;
-}
-
-qreal VSplinePoint::KAsm2() const{
-    return kAsm2;
-}
-
-void VSplinePoint::SetKAsm2(const qreal &value){
-    kAsm2 = value;
-}
diff --git a/geometry/vsplinepoint.h b/geometry/vsplinepoint.h
index 219e9fa96..ae9ffaeb5 100644
--- a/geometry/vsplinepoint.h
+++ b/geometry/vsplinepoint.h
@@ -32,62 +32,62 @@ public:
             /**
              * @brief VSplinePoint конструктор по замповчуванню.
              */
-            VSplinePoint();
+                  VSplinePoint();
             /**
              * @brief VSplinePoint конструктор.
              * @param pSpline точка сплайну.
              * @param angle кут дотичної сплайна.
              * @param factor коефіцієнт довжини дотичної.
              */
-            VSplinePoint(qint64 pSpline, qreal kAsm1, qreal angle, qreal kAsm2);
-            VSplinePoint(const VSplinePoint &point);
-            ~VSplinePoint();
+                  VSplinePoint(qint64 pSpline, qreal kAsm1, qreal angle, qreal kAsm2);
+                  VSplinePoint(const VSplinePoint &point);
+                  ~VSplinePoint() {}
     /**
      * @brief P повертає точку.
      * @return точка.
      */
-    qint64 P() const;
-    void SetP(const qint64 &value);
+    inline qint64 P() const {return pSpline;}
+    inline void   SetP(const qint64 &value) {pSpline = value;}
     /**
      * @brief Angle1 повертає кут дотичної сплайна.
      * @return кут в градусах.
      */
-    qreal   Angle1() const;
-    void    SetAngle(const qreal &value);
+    inline qreal  Angle1() const {return angle+180;}
+    inline void   SetAngle(const qreal &value) {angle = value;}
     /**
      * @brief Angle2 повертає кут дотичної сплайна.
      * @return кут в градусах.
      */
-    qreal   Angle2() const;
+    inline qreal  Angle2() const {return angle;}
     /**
      * @brief KAsm1 повертає коефіцієнт довжини дотичної.
      * @return коефіцієнт.
      */
-    qreal   KAsm1() const;
-    void    SetKAsm1(const qreal &value);
+    inline qreal  KAsm1() const {return kAsm1;}
+    inline void   SetKAsm1(const qreal &value) {kAsm1 = value;}
     /**
      * @brief KAsm2 повертає коефіцієнт довжини дотичної.
      * @return коефіцієнт.
      */
-    qreal   KAsm2() const;
-    void    SetKAsm2(const qreal &value);
+    inline qreal  KAsm2() const {return kAsm2;}
+    inline void   SetKAsm2(const qreal &value) {kAsm2 = value;}
 protected:
     /**
      * @brief pSpline точка сплайну.
      */
-    qint64 pSpline;
+    qint64        pSpline;
     /**
      * @brief angle кут дотичної сплайну.
      */
-    qreal   angle;
+    qreal         angle;
     /**
      * @brief kAsm1 коефіцієнт довжини дотичної сплайну.
      */
-    qreal   kAsm1;
+    qreal         kAsm1;
     /**
      * @brief kAsm2 коефіцієнт довжини дотичної сплайну.
      */
-    qreal   kAsm2;
+    qreal         kAsm2;
 };
 
 Q_DECLARE_METATYPE(VSplinePoint)