diff --git a/src/libs/vgeometry/vgobject.cpp b/src/libs/vgeometry/vgobject.cpp
index 573b5da3e..c2c3260de 100644
--- a/src/libs/vgeometry/vgobject.cpp
+++ b/src/libs/vgeometry/vgobject.cpp
@@ -472,6 +472,21 @@ bool VGObject::IsPointOnLineSegment(const QPointF &t, const QPointF &p1, const Q
     return IsPointOnLineviaPDP(t, p1, p2);
 }
 
+//---------------------------------------------------------------------------------------------------------------------
+QPointF VGObject::CorrectDistortion(const QPointF &t, const QPointF &p1, const QPointF &p2)
+{
+    if (not VFuzzyComparePoints(p1, p2))
+    {
+        QLineF line = QLineF(p1, p2);
+        line.setLength(QLineF(p1, VGObject::ClosestPoint(QLineF(p1, p2), t)).length());
+        return line.p2();
+    }
+    else
+    {
+        return t;
+    }
+}
+
 //---------------------------------------------------------------------------------------------------------------------
 /**
  * @brief IsPointOnLineviaPDP use the perp dot product (PDP) way.
diff --git a/src/libs/vgeometry/vgobject.h b/src/libs/vgeometry/vgobject.h
index 74eccac8f..89e99435c 100644
--- a/src/libs/vgeometry/vgobject.h
+++ b/src/libs/vgeometry/vgobject.h
@@ -97,6 +97,7 @@ public:
     static QPointF addVector (const QPointF &p, const QPointF &p1, const QPointF &p2, qreal k);
     static void    LineCoefficients(const QLineF &line, qreal *a, qreal *b, qreal *c);
     static bool    IsPointOnLineSegment (const QPointF &t, const QPointF &p1, const QPointF &p2);
+    static QPointF CorrectDistortion(const QPointF &t, const QPointF &p1, const QPointF &p2);
     static bool    IsPointOnLineviaPDP(const QPointF &t, const QPointF &p1, const QPointF &p2);
 
     template <typename T>
diff --git a/src/libs/vlayout/vabstractpiece.cpp b/src/libs/vlayout/vabstractpiece.cpp
index c44d96097..41aa9527c 100644
--- a/src/libs/vlayout/vabstractpiece.cpp
+++ b/src/libs/vlayout/vabstractpiece.cpp
@@ -263,8 +263,15 @@ QVector<QPointF> AngleByLength(QVector<QPointF> points, QPointF p2, const QLineF
     {
         if (not IsOutsidePoint(bigLine1.p1(), bigLine1.p2(), sp2))
         {
-            bool success = false;
-            points = RollbackSeamAllowance(points, bigLine2, &success);
+            if (p.GetAngleType() != PieceNodeAngle::ByLengthCurve)
+            {
+                bool success = false;
+                points = RollbackSeamAllowance(points, bigLine2, &success);
+            }
+            else
+            {
+                points.append(sp2);
+            }
         }
         else
         {
@@ -871,6 +878,9 @@ QVector<QPointF> VAbstractPiece::Equidistant(QVector<VSAPoint> points, qreal wid
         return QVector<QPointF>();
     }
 
+    // Fix distorsion
+    points = CorrectPathDistortion(points);
+
     if (points.last().toPoint() != points.first().toPoint())
     {
         points.append(points.at(0));// Should be always closed
@@ -1102,21 +1112,15 @@ QVector<QPointF> VAbstractPiece::EkvPoint(QVector<QPointF> points, const VSAPoin
         return QVector<QPointF>(); // Wrong edges
     }
 
-    // Correct distorsion
-    if (VGObject::IsPointOnLineSegment(p2Line1, p1Line1, p1Line2))
-    {
-        QLineF line = QLineF(p1Line1, p1Line2);
-        line.setLength(QLineF(p1Line1, p2Line1).length());
-
-        p2Line1.setX(line.p2().x());
-        p2Line1.setY(line.p2().y());
-
-        p2Line2.setX(line.p2().x());
-        p2Line2.setY(line.p2().y());
-    }
-
     const QLineF bigLine1 = ParallelLine(p1Line1, p2Line1, width );
     const QLineF bigLine2 = ParallelLine(p2Line2, p1Line2, width );
+
+    if (VFuzzyComparePoints(bigLine1.p2(), bigLine2.p1()))
+    {
+        points.append(bigLine1.p2());
+        return points;
+    }
+
     QPointF crosPoint;
     const QLineF::IntersectType type = bigLine1.intersect( bigLine2, &crosPoint );
     switch (type)
@@ -1129,8 +1133,21 @@ QVector<QPointF> VAbstractPiece::EkvPoint(QVector<QPointF> points, const VSAPoin
         { // Most common case
             /* Case when a path has point on line (both segments lie on the same line) and seam allowance creates
              * prong. */
+            auto IsOnLine = [](const QPointF &base, const QPointF &sp1, const QPointF &sp2)
+            {
+                if (not VFuzzyComparePoints(base, sp1))
+                {
+                    return VGObject::IsPointOnLineviaPDP(sp2, base, sp1);
+                }
+
+                if (not VFuzzyComparePoints(base, sp2))
+                {
+                    return VGObject::IsPointOnLineviaPDP(sp1, base, sp2);
+                }
+                return true;
+            };
             if (VGObject::IsPointOnLineSegment(p2Line1, p1Line1, p1Line2)
-                    && qAbs(QLineF(p2Line1, bigLine1.p2()).angle() - QLineF(p2Line1, bigLine2.p1()).angle()) < 0.001)
+                    && IsOnLine(p2Line1, bigLine1.p2(), bigLine2.p1()))
             {
                 points.append(bigLine1.p2());
                 points.append(bigLine2.p1());
diff --git a/src/libs/vlayout/vabstractpiece.h b/src/libs/vlayout/vabstractpiece.h
index 229840455..2c357041b 100644
--- a/src/libs/vlayout/vabstractpiece.h
+++ b/src/libs/vlayout/vabstractpiece.h
@@ -190,6 +190,9 @@ public:
                                      const VSAPoint &p1Line2, VSAPoint p2Line2, qreal width);
     static QLineF           ParallelLine(const VSAPoint &p1, const VSAPoint &p2, qreal width);
 
+    template <class T>
+    static QVector<T> CorrectPathDistortion(QVector<T> path);
+
     template <class T>
     static QVector<T> CorrectEquidistantPoints(const QVector<T> &points, bool removeFirstAndLast = true);
 
@@ -207,6 +210,44 @@ private:
 
 Q_DECLARE_TYPEINFO(VAbstractPiece, Q_MOVABLE_TYPE);
 
+//---------------------------------------------------------------------------------------------------------------------
+template<class T>
+QVector<T> VAbstractPiece::CorrectPathDistortion(QVector<T> path)
+{
+    if (path.size() < 3)
+    {
+        return path;
+    }
+
+    int prev = -1;
+    for (qint32 i = 0; i < path.size(); ++i)
+    {
+        if (prev == -1)
+        {
+            i == 0 ? prev = path.size() - 1 : prev = i-1;
+        }
+
+        int next = i+1;
+        if (i == path.size() - 1)
+        {
+            next = 0;
+        }
+
+        const QPointF &iPoint = path.at(i);
+        const QPointF &prevPoint = path.at(prev);
+        const QPointF &nextPoint = path.at(next);
+
+        if (VGObject::IsPointOnLineSegment(iPoint, prevPoint, nextPoint))
+        {
+            const QPointF p = VGObject::CorrectDistortion(iPoint, prevPoint, nextPoint);
+            path[i].setX(p.x());
+            path[i].setY(p.y());
+        }
+    }
+
+    return path;
+}
+
 //---------------------------------------------------------------------------------------------------------------------
 /**
  * @brief CorrectEquidistantPoints clear equivalent points and remove point on line from equdistant.
diff --git a/src/libs/vpatterndb/vpiece.cpp b/src/libs/vpatterndb/vpiece.cpp
index f80778e18..fb08f8578 100644
--- a/src/libs/vpatterndb/vpiece.cpp
+++ b/src/libs/vpatterndb/vpiece.cpp
@@ -1104,7 +1104,7 @@ bool VPiece::GetPassmarkPreviousSAPoints(const QVector<VPieceNode> &path, int in
     do
     {
         const VSAPoint previous = points.at(nodeIndex);
-        if (passmarkSAPoint.toPoint() != previous.toPoint())
+        if (not VFuzzyComparePoints(passmarkSAPoint, previous))
         {
             point = previous;
             found = true;
@@ -1141,7 +1141,7 @@ int VPiece::GetPassmarkNextSAPoints(const QVector<VPieceNode> &path, int index,
     do
     {
         const VSAPoint next = points.at(nodeIndex);
-        if (passmarkSAPoint.toPoint() != next.toPoint())
+        if (not VFuzzyComparePoints(passmarkSAPoint, next))
         {
             point = next;
             found = true;
@@ -1159,32 +1159,22 @@ int VPiece::GetPassmarkNextSAPoints(const QVector<VPieceNode> &path, int index,
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-bool VPiece::GetSeamPassmarkSAPoint(const VSAPoint &previousSAPoint, const VSAPoint &passmarkSAPoint,
+bool VPiece::GetSeamPassmarkSAPoint(const VSAPoint &previousSAPoint, VSAPoint passmarkSAPoint,
                                     const VSAPoint &nextSAPoint, const VContainer *data, QPointF &point) const
 {
     SCASSERT(data != nullptr)
 
-    QVector<QPointF> ekvPoints;
-    const qreal width = ToPixel(GetSAWidth(), *data->GetPatternUnit());
+    // Correct distorsion
+    if (VGObject::IsPointOnLineSegment(passmarkSAPoint, previousSAPoint, nextSAPoint))
+    {
+        const QPointF p = VGObject::CorrectDistortion(passmarkSAPoint, previousSAPoint, nextSAPoint);
+        passmarkSAPoint.setX(p.x());
+        passmarkSAPoint.setY(p.y());
+    }
 
-    /* Because method VAbstractPiece::EkvPoint has troubles with edges on a same line we should specially treat such
-       cases.
-       First check if two edges and seam alowance create paralell lines.
-       Second case check if two edges are on a same line geometrically and a passmark point has equal SA width.*/
-    if (IsEkvPointOnLine(passmarkSAPoint, previousSAPoint, nextSAPoint)// see issue #665
-        || (IsEkvPointOnLine(static_cast<QPointF>(passmarkSAPoint), static_cast<QPointF>(previousSAPoint),
-                             static_cast<QPointF>(nextSAPoint))
-            && qAbs(passmarkSAPoint.GetSABefore(width) - passmarkSAPoint.GetSAAfter(width)) < accuracyPointOnLine))
-    {
-        QLineF line (passmarkSAPoint, nextSAPoint);
-        line.setAngle(line.angle() + 90);
-        line.setLength(passmarkSAPoint.MaxLocalSA(width));
-        ekvPoints.append(line.p2());
-    }
-    else
-    {
-        ekvPoints = EkvPoint(ekvPoints, previousSAPoint, passmarkSAPoint, nextSAPoint, passmarkSAPoint, width);
-    }
+    QVector<QPointF> ekvPoints;
+    ekvPoints = EkvPoint(ekvPoints, previousSAPoint, passmarkSAPoint, nextSAPoint, passmarkSAPoint,
+                         ToPixel(GetSAWidth(), *data->GetPatternUnit()));
 
     if (ekvPoints.isEmpty())
     { // Just in case
diff --git a/src/libs/vpatterndb/vpiece.h b/src/libs/vpatterndb/vpiece.h
index bc6e75254..841919b93 100644
--- a/src/libs/vpatterndb/vpiece.h
+++ b/src/libs/vpatterndb/vpiece.h
@@ -145,7 +145,7 @@ private:
                                      const VContainer *data, VSAPoint &point, int passmarkIndex) const;
     int GetPassmarkNextSAPoints(const QVector<VPieceNode> &path, int index, const VSAPoint &passmarkSAPoint,
                                 const VContainer *data, VSAPoint &point, int passmarkIndex) const;
-    bool GetSeamPassmarkSAPoint(const VSAPoint &previousSAPoint, const VSAPoint &passmarkSAPoint,
+    bool GetSeamPassmarkSAPoint(const VSAPoint &previousSAPoint, VSAPoint passmarkSAPoint,
                                 const VSAPoint &nextSAPoint, const VContainer *data, QPointF &point) const;
 
     bool IsPassmarkVisible(const QVector<VPieceNode> &path, int passmarkIndex) const;
diff --git a/src/test/ValentinaTest/tst_vabstractpiece.cpp b/src/test/ValentinaTest/tst_vabstractpiece.cpp
index a76de06f5..8d1697a00 100644
--- a/src/test/ValentinaTest/tst_vabstractpiece.cpp
+++ b/src/test/ValentinaTest/tst_vabstractpiece.cpp
@@ -402,7 +402,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByAngle() const
     points += QPointF(81.746054423686445, -0.275895198174861);
     points += QPointF(119.502088280527815, -5.192452541281906);
     points += QPointF(148.425957227782732, -10.854963023883784);
-    points += QPointF(167.448600561093770, -15.907328733562260);
+    points += QPointF(167.556696145037904, -15.490385095876569);
     points += QPointF(186.612816424205562, -20.944957847774820);
     points += QPointF(205.319505657476242, -27.211791809853210);
     points += QPointF(223.517364434872150, -34.306381867523655);
@@ -427,8 +427,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByAngle() const
     points += QPointF(1002.542920964105861, 549.634087483703752);
     points += QPointF(1001.809643735979421, 561.617500931810469);
     points += QPointF(1001.632561636561945, 577.019027819914413);
-    points += QPointF(1003.005943695759470, 595.324545904181832);
-    points += QPointF(1003.122677531314821, 597.878021988163141);
+    points += QPointF(1002.598207939668328, 593.497788561921766);
+    points += QPointF(1003.041928141414928, 597.870394747796013);
     points += QPointF(1003.192654042237791, 599.136324774537911);
     points += QPointF(1004.471571421798103, 605.713997489163717);
     points += QPointF(1006.667223943402178, 613.597204585595591);
@@ -441,15 +441,15 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByAngle() const
     points += QPointF(1051.171411576988021, 682.376198541660301);
     points += QPointF(1060.187810189582478, 689.465144441703842);
     points += QPointF(1066.614334108267713, 693.625487703081035);
-    points += QPointF(1070.257199304126971, 695.293432907079136);
-    points += QPointF(1074.502615007352006, 697.381379428831451);
-    points += QPointF(1078.826982655972415, 699.218630270296671);
-    points += QPointF(1083.285021824863634, 700.822525916039240);
+    points += QPointF(1070.121252449300300, 695.602265955357211);
+    points += QPointF(1074.383015113466399, 697.709664964041394);
+    points += QPointF(1078.726580541966541, 699.565875909043029);
+    points += QPointF(1083.206554246492033, 701.187803413440861);
     points += QPointF(1087.891993301368984, 702.585863211688206);
     points += QPointF(1092.864668865585145, 703.760519908174842);
     points += QPointF(1098.216223912539590, 704.699271425243978);
     points += QPointF(1104.044420848225172, 705.374446205546178);
-    points += QPointF(1112.817242174511875, 705.622046059863806);
+    points += QPointF(1111.348801411629438, 705.793755950627201);
     points += QPointF(1290.270553665008265, 707.499620616224888);
     points += QPointF(1302.416131870576919, 881.655825604373376);
     points += QPointF(30.000000000000000, 970.393574803149590);
@@ -723,7 +723,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByIntersection()
     points += QPointF(81.746054423686445, -0.275895198174861);
     points += QPointF(119.502088280527815, -5.192452541281906);
     points += QPointF(148.425957227782732, -10.854963023883784);
-    points += QPointF(167.448600561093770, -15.907328733562260);
+    points += QPointF(167.556696145037904, -15.490385095876569);
     points += QPointF(186.612816424205562, -20.944957847774820);
     points += QPointF(205.319505657476242, -27.211791809853210);
     points += QPointF(223.517364434872150, -34.306381867523655);
@@ -749,8 +749,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByIntersection()
     points += QPointF(1002.542920964105861, 549.634087483703752);
     points += QPointF(1001.809643735979421, 561.617500931810469);
     points += QPointF(1001.632561636561945, 577.019027819914413);
-    points += QPointF(1003.005943695759470, 595.324545904181832);
-    points += QPointF(1003.122677531314821, 597.878021988163141);
+    points += QPointF(1002.598207939668328, 593.497788561921766);
+    points += QPointF(1003.041928141414928, 597.870394747796013);
     points += QPointF(1003.192654042237791, 599.136324774537911);
     points += QPointF(1004.471571421798103, 605.713997489163717);
     points += QPointF(1006.667223943402178, 613.597204585595591);
@@ -763,15 +763,15 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByIntersection()
     points += QPointF(1051.171411576988021, 682.376198541660301);
     points += QPointF(1060.187810189582478, 689.465144441703842);
     points += QPointF(1066.614334108267713, 693.625487703081035);
-    points += QPointF(1070.257199304126971, 695.293432907079136);
-    points += QPointF(1074.502615007352006, 697.381379428831451);
-    points += QPointF(1078.826982655972415, 699.218630270296671);
-    points += QPointF(1083.285021824863634, 700.822525916039240);
+    points += QPointF(1070.121252449300300, 695.602265955357211);
+    points += QPointF(1074.383015113466399, 697.709664964041394);
+    points += QPointF(1078.726580541966541, 699.565875909043029);
+    points += QPointF(1083.206554246492033, 701.187803413440861);
     points += QPointF(1087.891993301368984, 702.585863211688206);
     points += QPointF(1092.864668865585145, 703.760519908174842);
     points += QPointF(1098.216223912539590, 704.699271425243978);
     points += QPointF(1104.044420848225172, 705.374446205546178);
-    points += QPointF(1112.817242174511875, 705.622046059863806);
+    points += QPointF(1111.348801411629438, 705.793755950627201);
     points += QPointF(1290.270553665008265, 707.499620616224888);
     points += QPointF(1302.416131870576919, 881.655825604373376);
     points += QPointF(30.000000000000000, 970.393574803149590);
@@ -1045,7 +1045,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByFirstEdgeSymmer
     points += QPointF(81.746054423686445, -0.275895198174861);
     points += QPointF(119.502088280527815, -5.192452541281906);
     points += QPointF(148.425957227782732, -10.854963023883784);
-    points += QPointF(167.448600561093770, -15.907328733562260);
+    points += QPointF(167.556696145037904, -15.490385095876569);
     points += QPointF(186.612816424205562, -20.944957847774820);
     points += QPointF(205.319505657476242, -27.211791809853210);
     points += QPointF(223.517364434872150, -34.306381867523655);
@@ -1073,8 +1073,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByFirstEdgeSymmer
     points += QPointF(1002.542920964105861, 549.634087483703752);
     points += QPointF(1001.809643735979421, 561.617500931810469);
     points += QPointF(1001.632561636561945, 577.019027819914413);
-    points += QPointF(1003.005943695759470, 595.324545904181832);
-    points += QPointF(1003.122677531314821, 597.878021988163141);
+    points += QPointF(1002.598207939668328, 593.497788561921766);
+    points += QPointF(1003.041928141414928, 597.870394747796013);
     points += QPointF(1003.192654042237791, 599.136324774537911);
     points += QPointF(1004.471571421798103, 605.713997489163717);
     points += QPointF(1006.667223943402178, 613.597204585595591);
@@ -1087,15 +1087,15 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByFirstEdgeSymmer
     points += QPointF(1051.171411576988021, 682.376198541660301);
     points += QPointF(1060.187810189582478, 689.465144441703842);
     points += QPointF(1066.614334108267713, 693.625487703081035);
-    points += QPointF(1070.257199304126971, 695.293432907079136);
-    points += QPointF(1074.502615007352006, 697.381379428831451);
-    points += QPointF(1078.826982655972415, 699.218630270296671);
-    points += QPointF(1083.285021824863634, 700.822525916039240);
+    points += QPointF(1070.121252449300300, 695.602265955357211);
+    points += QPointF(1074.383015113466399, 697.709664964041394);
+    points += QPointF(1078.726580541966541, 699.565875909043029);
+    points += QPointF(1083.206554246492033, 701.187803413440861);
     points += QPointF(1087.891993301368984, 702.585863211688206);
     points += QPointF(1092.864668865585145, 703.760519908174842);
     points += QPointF(1098.216223912539590, 704.699271425243978);
     points += QPointF(1104.044420848225172, 705.374446205546178);
-    points += QPointF(1112.817242174511875, 705.622046059863806);
+    points += QPointF(1111.348801411629438, 705.793755950627201);
     points += QPointF(1290.270553665008265, 707.499620616224888);
     points += QPointF(1302.416131870576919, 881.655825604373376);
     points += QPointF(30.000000000000000, 970.393574803149590);
@@ -1369,7 +1369,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceBySecondEdgeSymme
     points += QPointF(81.746054423686445, -0.275895198174861);
     points += QPointF(119.502088280527815, -5.192452541281906);
     points += QPointF(148.425957227782732, -10.854963023883784);
-    points += QPointF(167.448600561093770, -15.907328733562260);
+    points += QPointF(167.556696145037904, -15.490385095876569);
     points += QPointF(186.612816424205562, -20.944957847774820);
     points += QPointF(205.319505657476242, -27.211791809853210);
     points += QPointF(223.517364434872150, -34.306381867523655);
@@ -1395,8 +1395,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceBySecondEdgeSymme
     points += QPointF(1002.542920964105861, 549.634087483703752);
     points += QPointF(1001.809643735979421, 561.617500931810469);
     points += QPointF(1001.632561636561945, 577.019027819914413);
-    points += QPointF(1003.005943695759470, 595.324545904181832);
-    points += QPointF(1003.122677531314821, 597.878021988163141);
+    points += QPointF(1002.598207939668328, 593.497788561921766);
+    points += QPointF(1003.041928141414928, 597.870394747796013);
     points += QPointF(1003.192654042237791, 599.136324774537911);
     points += QPointF(1004.471571421798103, 605.713997489163717);
     points += QPointF(1006.667223943402178, 613.597204585595591);
@@ -1409,15 +1409,15 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceBySecondEdgeSymme
     points += QPointF(1051.171411576988021, 682.376198541660301);
     points += QPointF(1060.187810189582478, 689.465144441703842);
     points += QPointF(1066.614334108267713, 693.625487703081035);
-    points += QPointF(1070.257199304126971, 695.293432907079136);
-    points += QPointF(1074.502615007352006, 697.381379428831451);
-    points += QPointF(1078.826982655972415, 699.218630270296671);
-    points += QPointF(1083.285021824863634, 700.822525916039240);
+    points += QPointF(1070.121252449300300, 695.602265955357211);
+    points += QPointF(1074.383015113466399, 697.709664964041394);
+    points += QPointF(1078.726580541966541, 699.565875909043029);
+    points += QPointF(1083.206554246492033, 701.187803413440861);
     points += QPointF(1087.891993301368984, 702.585863211688206);
     points += QPointF(1092.864668865585145, 703.760519908174842);
     points += QPointF(1098.216223912539590, 704.699271425243978);
     points += QPointF(1104.044420848225172, 705.374446205546178);
-    points += QPointF(1112.817242174511875, 705.622046059863806);
+    points += QPointF(1111.348801411629438, 705.793755950627201);
     points += QPointF(1290.270553665008265, 707.499620616224888);
     points += QPointF(1302.416131870576919, 881.655825604373376);
     points += QPointF(30.000000000000000, 970.393574803149590);
@@ -1691,7 +1691,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByFirstRightAngle
     points += QPointF(81.746054423686445, -0.275895198174861);
     points += QPointF(119.502088280527815, -5.192452541281906);
     points += QPointF(148.425957227782732, -10.854963023883784);
-    points += QPointF(167.448600561093770, -15.907328733562260);
+    points += QPointF(167.556696145037904, -15.490385095876569);
     points += QPointF(186.612816424205562, -20.944957847774820);
     points += QPointF(205.319505657476242, -27.211791809853210);
     points += QPointF(223.517364434872150, -34.306381867523655);
@@ -1719,8 +1719,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByFirstRightAngle
     points += QPointF(1002.542920964105861, 549.634087483703752);
     points += QPointF(1001.809643735979421, 561.617500931810469);
     points += QPointF(1001.632561636561945, 577.019027819914413);
-    points += QPointF(1003.005943695759470, 595.324545904181832);
-    points += QPointF(1003.122677531314821, 597.878021988163141);
+    points += QPointF(1002.598207939668328, 593.497788561921766);
+    points += QPointF(1003.041928141414928, 597.870394747796013);
     points += QPointF(1003.192654042237791, 599.136324774537911);
     points += QPointF(1004.471571421798103, 605.713997489163717);
     points += QPointF(1006.667223943402178, 613.597204585595591);
@@ -1733,15 +1733,15 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceByFirstRightAngle
     points += QPointF(1051.171411576988021, 682.376198541660301);
     points += QPointF(1060.187810189582478, 689.465144441703842);
     points += QPointF(1066.614334108267713, 693.625487703081035);
-    points += QPointF(1070.257199304126971, 695.293432907079136);
-    points += QPointF(1074.502615007352006, 697.381379428831451);
-    points += QPointF(1078.826982655972415, 699.218630270296671);
-    points += QPointF(1083.285021824863634, 700.822525916039240);
+    points += QPointF(1070.121252449300300, 695.602265955357211);
+    points += QPointF(1074.383015113466399, 697.709664964041394);
+    points += QPointF(1078.726580541966541, 699.565875909043029);
+    points += QPointF(1083.206554246492033, 701.187803413440861);
     points += QPointF(1087.891993301368984, 702.585863211688206);
     points += QPointF(1092.864668865585145, 703.760519908174842);
     points += QPointF(1098.216223912539590, 704.699271425243978);
     points += QPointF(1104.044420848225172, 705.374446205546178);
-    points += QPointF(1112.817242174511875, 705.622046059863806);
+    points += QPointF(1111.348801411629438, 705.793755950627201);
     points += QPointF(1290.270553665008265, 707.499620616224888);
     points += QPointF(1302.416131870576919, 881.655825604373376);
     points += QPointF(30.000000000000000, 970.393574803149590);
@@ -2015,7 +2015,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceBySecondRightAngl
     points += QPointF(81.746054423686445, -0.275895198174861);
     points += QPointF(119.502088280527815, -5.192452541281906);
     points += QPointF(148.425957227782732, -10.854963023883784);
-    points += QPointF(167.448600561093770, -15.907328733562260);
+    points += QPointF(167.556696145037904, -15.490385095876569);
     points += QPointF(186.612816424205562, -20.944957847774820);
     points += QPointF(205.319505657476242, -27.211791809853210);
     points += QPointF(223.517364434872150, -34.306381867523655);
@@ -2040,8 +2040,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceBySecondRightAngl
     points += QPointF(1002.542920964105861, 549.634087483703752);
     points += QPointF(1001.809643735979421, 561.617500931810469);
     points += QPointF(1001.632561636561945, 577.019027819914413);
-    points += QPointF(1003.005943695759470, 595.324545904181832);
-    points += QPointF(1003.122677531314821, 597.878021988163141);
+    points += QPointF(1002.598207939668328, 593.497788561921766);
+    points += QPointF(1003.041928141414928, 597.870394747796013);
     points += QPointF(1003.192654042237791, 599.136324774537911);
     points += QPointF(1004.471571421798103, 605.713997489163717);
     points += QPointF(1006.667223943402178, 613.597204585595591);
@@ -2054,15 +2054,15 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsSeamTest1PieceBySecondRightAngl
     points += QPointF(1051.171411576988021, 682.376198541660301);
     points += QPointF(1060.187810189582478, 689.465144441703842);
     points += QPointF(1066.614334108267713, 693.625487703081035);
-    points += QPointF(1070.257199304126971, 695.293432907079136);
-    points += QPointF(1074.502615007352006, 697.381379428831451);
-    points += QPointF(1078.826982655972415, 699.218630270296671);
-    points += QPointF(1083.285021824863634, 700.822525916039240);
+    points += QPointF(1070.121252449300300, 695.602265955357211);
+    points += QPointF(1074.383015113466399, 697.709664964041394);
+    points += QPointF(1078.726580541966541, 699.565875909043029);
+    points += QPointF(1083.206554246492033, 701.187803413440861);
     points += QPointF(1087.891993301368984, 702.585863211688206);
     points += QPointF(1092.864668865585145, 703.760519908174842);
     points += QPointF(1098.216223912539590, 704.699271425243978);
     points += QPointF(1104.044420848225172, 705.374446205546178);
-    points += QPointF(1112.817242174511875, 705.622046059863806);
+    points += QPointF(1111.348801411629438, 705.793755950627201);
     points += QPointF(1290.270553665008265, 707.499620616224888);
     points += QPointF(1302.416131870576919, 881.655825604373376);
     points += QPointF(30.000000000000000, 970.393574803149590);
@@ -2334,11 +2334,11 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsCase2() const
     points += QPointF(6.735602489575015, 2.204598425196849);
     points += QPointF(445.748031496063049, 2.204598425196849);
     points += QPointF(445.748031496062993, 251.484462700721508);
-    points += QPointF(419.591110849233189, 265.317270648671297);
-    points += QPointF(407.953210071604417, 270.322402348478022);
-    points += QPointF(395.580263781148915, 274.639711080216728);
-    points += QPointF(383.140340834693006, 277.792967801099280);
-    points += QPointF(370.724173666002685, 279.828447786037486);
+    points += QPointF(420.167249883446971, 265.344673769224812);
+    points += QPointF(408.168687600939791, 270.749698109742667);
+    points += QPointF(395.757434861670447, 275.068217221903126);
+    points += QPointF(383.280158875837515, 278.216263504481446);
+    points += QPointF(370.828801869607219, 280.240944580682424);
     points += QPointF(358.240833427700807, 281.223585390784933);
     points += QPointF(340.128405605847377, 280.950325398745633);
     points += QPointF(317.100367222628677, 277.461014499073372);
@@ -2349,8 +2349,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsCase2() const
     points += QPointF(223.168378143141126, 227.069612826995268);
     points += QPointF(209.577497139717309, 213.238868162572516);
     points += QPointF(197.938119214048157, 198.672641760685593);
-    points += QPointF(195.334197289257986, 194.470624417595133);
-    points += QPointF(185.650431199796770, 196.441071788419436);
+    points += QPointF(195.608727121505524, 194.913640433289544);
+    points += QPointF(185.710682244992483, 196.880382798455116);
     points += QPointF(173.809356654777872, 198.035763353667477);
     points += QPointF(156.584623464047553, 197.972079562468082);
     points += QPointF(133.847493016660877, 194.874025486507207);
@@ -2361,13 +2361,13 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsCase2() const
     points += QPointF(29.800888286137585, 143.652949766683832);
     points += QPointF(13.683525778751441, 127.384450781512541);
     points += QPointF(3.399493823857615, 113.515501757126160);
-    points += QPointF(-2.224241185040267, 102.935005111895975);
+    points += QPointF(-2.688329116224859, 103.081091306820881);
     points += QPointF(-7.591302295481950, 92.078476678883646);
     points += QPointF(-11.187498192466251, 80.235473513717892);
     points += QPointF(-13.151329445248951, 67.623242575048394);
     points += QPointF(-13.149174973239838, 54.474730078465917);
     points += QPointF(-10.943375405772395, 41.194056317965945);
-    points += QPointF(-6.573018301423769, 29.688707734798065);
+    points += QPointF(-6.654890290296288, 28.745230957359055);
     points += QPointF(6.735602489575015, 2.204598425196849);
 
     return points;
@@ -2378,324 +2378,419 @@ QVector<VSAPoint> TST_VAbstractPiece::InputPointsCase3() const
 {
     QVector<VSAPoint> points;
 
-//    p = VSAPoint(25.837720078200917, 50.514253279672296);
-//    p.SetSABefore(37.81114840454936);
-//    p.SetSAAfter(37.81114840454936);
-//    points.append(p);
+    points += VSAPoint(30.000000000000000, 39.999874015748034);
+    points += VSAPoint(407.952755905511822, 39.999874015748034);
+    points += VSAPoint(407.952755905511822, 228.976251968503959);
+    points += VSAPoint(407.952755905511822, 228.976251968503959);
 
-    points.append(VSAPoint(30.0, 39.999874015748034));
-    points.append(VSAPoint(407.9527559055118, 39.999874015748034));
-    points.append(VSAPoint(407.9527559055118, 228.97625196850396));
-    points.append(VSAPoint(407.9527559055118, 228.97625196850396));
+    VSAPoint p = VSAPoint(404.672301299224387, 235.656234316977816);
+    p.SetSABefore(36.9778);
+    p.SetSAAfter(36.9778);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    VSAPoint p = VSAPoint(404.6723012992244, 235.65623431697782);
-    p.SetSABefore(36.977845511186636);
-    p.SetSAAfter(36.977845511186636);
-    points.append(p);
+    p = VSAPoint(397.222833003011260, 246.532690980461950);
+    p.SetSABefore(35.5298);
+    p.SetSAAfter(35.5298);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(397.22283300301126, 246.53269098046195);
-    p.SetSABefore(35.52982410231174);
-    p.SetSAAfter(35.52982410231174);
-    points.append(p);
+    p = VSAPoint(388.920624996308561, 254.595637637351388);
+    p.SetSABefore(34.2586);
+    p.SetSAAfter(34.2586);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(388.92062499630856, 254.5956376373514);
-    p.SetSABefore(34.258630321759945);
-    p.SetSAAfter(34.258630321759945);
-    points.append(p);
+    p = VSAPoint(380.002934156756680, 260.030296102714601);
+    p.SetSABefore(33.1115);
+    p.SetSAAfter(33.1115);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(380.0029341567567, 260.0302961027146);
-    p.SetSABefore(33.111548444754845);
-    p.SetSAAfter(33.111548444754845);
-    points.append(p);
+    p = VSAPoint(370.707017361996236, 263.021888191619951);
+    p.SetSABefore(32.0389);
+    p.SetSAAfter(32.0389);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(370.70701736199624, 263.02188819161995);
-    p.SetSABefore(32.03891394371319);
-    p.SetSAAfter(32.03891394371319);
-    points.append(p);
+    p = VSAPoint(361.270131489667733, 263.755635719135853);
+    p.SetSABefore(30.9992);
+    p.SetSAAfter(30.9992);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(361.27013148966773, 263.75563571913585);
-    p.SetSABefore(30.99923856743404);
-    p.SetSAAfter(30.99923856743404);
-    points.append(p);
+    p = VSAPoint(351.929533417411790, 262.416760500330838);
+    p.SetSABefore(29.9628);
+    p.SetSAAfter(29.9628);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(351.9295334174118, 262.41676050033084);
-    p.SetSABefore(29.962781670363757);
-    p.SetSAAfter(29.962781670363757);
-    points.append(p);
+    p = VSAPoint(342.922480022868967, 259.190484350273266);
+    p.SetSABefore(28.9119);
+    p.SetSAAfter(28.9119);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(342.92248002286897, 259.19048435027327);
-    p.SetSABefore(28.91189499226486);
-    p.SetSAAfter(28.91189499226486);
-    points.append(p);
+    p = VSAPoint(334.486228183679657, 254.262029084031553);
+    p.SetSABefore(27.8387);
+    p.SetSAAfter(27.8387);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(334.48622818367966, 254.26202908403155);
-    p.SetSABefore(27.838718909311048);
-    p.SetSAAfter(27.838718909311048);
-    points.append(p);
+    p = VSAPoint(326.858034777484477, 247.816616516674173);
+    p.SetSABefore(26.7418);
+    p.SetSAAfter(26.7418);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(326.8580347774845, 247.81661651667417);
-    p.SetSABefore(26.741788760884347);
-    p.SetSAAfter(26.741788760884347);
-    points.append(p);
+    p = VSAPoint(320.275156681923932, 240.039468463269486);
+    p.SetSABefore(25.6226);
+    p.SetSAAfter(25.6226);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(320.27515668192393, 240.0394684632695);
-    p.SetSABefore(25.622615764841164);
-    p.SetSAAfter(25.622615764841164);
-    points.append(p);
+    p = VSAPoint(314.974850774638639, 231.115806738886022);
+    p.SetSABefore(24.4826);
+    p.SetSAAfter(24.4826);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(314.97485077463864, 231.11580673888602);
-    p.SetSABefore(24.482580077336745);
-    p.SetSAAfter(24.482580077336745);
-    points.append(p);
+    p = VSAPoint(311.194373933269048, 221.230853158592197);
+    p.SetSABefore(23.3201);
+    p.SetSAAfter(23.3201);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(311.19437393326905, 221.2308531585922);
-    p.SetSABefore(23.320121181910643);
-    p.SetSAAfter(23.320121181910643);
-    points.append(p);
+    p = VSAPoint(309.170983035455720, 210.569829537456371);
+    p.SetSABefore(22.1282);
+    p.SetSAAfter(22.1282);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(309.1709830354557, 210.56982953745637);
-    p.SetSABefore(22.12821102042642);
-    p.SetSAAfter(22.12821102042642);
-    points.append(p);
+    p = VSAPoint(309.141934958839045, 199.317957690547019);
+    p.SetSABefore(20.8923);
+    p.SetSAAfter(20.8923);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(309.14193495883904, 199.31795769054702);
-    p.SetSABefore(20.89230212706225);
-    p.SetSAAfter(20.89230212706225);
-    points.append(p);
+    p = VSAPoint(311.344486581059869, 187.660459432932583);
+    p.SetSABefore(19.5892);
+    p.SetSAAfter(19.5892);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(311.34448658105987, 187.66045943293258);
-    p.SetSABefore(19.58918900085386);
-    p.SetSAAfter(19.58918900085386);
-    points.append(p);
+    p = VSAPoint(313.464566929134321, 181.732157480315578);
+    p.SetSABefore(18.8976);
+    p.SetSAAfter(18.8976);
+    points += p;
 
-    p = VSAPoint(313.4645669291343, 181.73215748031558);
-    p.SetSABefore(18.897637795275593);
-    p.SetSAAfter(18.897637795275593);
-    points.append(p);
+    p = VSAPoint(313.464566929134321, 181.732157480315578);
+    p.SetSABefore(18.8976);
+    p.SetSAAfter(18.8976);
+    points += p;
 
-    p = VSAPoint(313.4645669291343, 181.73215748031558);
-    p.SetSABefore(18.897637795275593);
-    p.SetSAAfter(18.897637795275593);
-    points.append(p);
+    p = VSAPoint(313.464566929134321, 181.732157480315578);
+    p.SetSABefore(18.8976);
+    p.SetSAAfter(18.8976);
+    points += p;
 
-    p = VSAPoint(313.4645669291343, 181.73215748031558);
-    p.SetSABefore(18.897637795275593);
-    p.SetSAAfter(18.897637795275593);
-    points.append(p);
+    p = VSAPoint(316.591345021592019, 173.284435565430954);
+    p.SetSABefore(19.9768);
+    p.SetSAAfter(19.9768);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(316.591345021592, 173.28443556543095);
-    p.SetSABefore(19.976796375788812);
-    p.SetSAAfter(19.976796375788812);
-    points.append(p);
+    p = VSAPoint(320.142638433108914, 158.635688769582430);
+    p.SetSABefore(21.7826);
+    p.SetSAAfter(21.7826);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(320.1426384331089, 158.63568876958243);
-    p.SetSABefore(21.782587487730186);
-    p.SetSAAfter(21.782587487730186);
-    points.append(p);
+    p = VSAPoint(320.765122974842939, 146.512865040203337);
+    p.SetSABefore(23.2368);
+    p.SetSAAfter(23.2368);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(320.76512297484294, 146.51286504020334);
-    p.SetSABefore(23.23684508842329);
-    p.SetSAAfter(23.23684508842329);
-    points.append(p);
+    p = VSAPoint(318.807583600455132, 136.726949517032153);
+    p.SetSABefore(24.4324);
+    p.SetSAAfter(24.4324);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(318.80758360045513, 136.72694951703215);
-    p.SetSABefore(24.432447936360937);
-    p.SetSAAfter(24.432447936360937);
-    points.append(p);
+    p = VSAPoint(314.618805263606987, 129.088927339807270);
+    p.SetSABefore(25.4761);
+    p.SetSAAfter(25.4761);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(314.618805263607, 129.08892733980727);
-    p.SetSABefore(25.476072862288163);
-    p.SetSAAfter(25.476072862288163);
-    points.append(p);
+    p = VSAPoint(308.547572917959542, 123.409783648267165);
+    p.SetSABefore(26.472);
+    p.SetSAAfter(26.472);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(308.54757291795954, 123.40978364826717);
-    p.SetSABefore(26.47203809949214);
-    p.SetSAAfter(26.47203809949214);
-    points.append(p);
+    p = VSAPoint(300.942671517174290, 119.500503582150259);
+    p.SetSABefore(27.4965);
+    p.SetSAAfter(27.4965);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(300.9426715171743, 119.50050358215026);
-    p.SetSABefore(27.49645076170011);
-    p.SetSAAfter(27.49645076170011);
-    points.append(p);
+    p = VSAPoint(292.152886014912497, 117.172072281195000);
+    p.SetSABefore(28.5858);
+    p.SetSAAfter(28.5858);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(292.1528860149125, 117.172072281195);
-    p.SetSABefore(28.585809818498724);
-    p.SetSAAfter(28.585809818498724);
-    points.append(p);
+    p = VSAPoint(282.527001364835201, 116.235474885139837);
+    p.SetSABefore(29.7445);
+    p.SetSAAfter(29.7445);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(282.5270013648352, 116.23547488513984);
-    p.SetSABefore(29.74446055333082);
-    p.SetSAAfter(29.74446055333082);
-    points.append(p);
+    p = VSAPoint(272.413802520603895, 116.501696533723177);
+    p.SetSABefore(30.9565);
+    p.SetSAAfter(30.9565);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(272.4138025206039, 116.50169653372318);
-    p.SetSABefore(30.95646646201516);
-    p.SetSAAfter(30.95646646201516);
-    points.append(p);
+    p = VSAPoint(262.162074435879845, 117.781722366683496);
+    p.SetSABefore(32.1942);
+    p.SetSAAfter(32.1942);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(262.16207443587984, 117.7817223666835);
-    p.SetSABefore(32.19418539121919);
-    p.SetSAAfter(32.19418539121919);
-    points.append(p);
+    p = VSAPoint(252.120602064324260, 119.886537523759216);
+    p.SetSABefore(33.4233);
+    p.SetSAAfter(33.4233);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(252.12060206432426, 119.88653752375922);
-    p.SetSABefore(33.42332260663002);
-    p.SetSAAfter(33.42332260663002);
-    points.append(p);
+    p = VSAPoint(238.080312793150540, 124.132738713584303);
+    p.SetSABefore(35.1806);
+    p.SetSAAfter(35.1806);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(238.08031279315054, 124.1327387135843);
-    p.SetSABefore(35.18062492767001);
-    p.SetSAAfter(35.18062492767001);
-    points.append(p);
+    p = VSAPoint(226.745568765280950, 129.259570337063167);
+    p.SetSABefore(36.671);
+    p.SetSAAfter(36.671);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(226.74556876528095, 129.25957033706317);
-    p.SetSABefore(36.67100242816486);
-    p.SetSAAfter(36.67100242816486);
-    points.append(p);
+    p = VSAPoint(221.032968783011938, 132.773394187984877);
+    p.SetSABefore(37.4745);
+    p.SetSAAfter(37.4745);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(221.03296878301194, 132.77339418798488);
-    p.SetSABefore(37.47448996772893);
-    p.SetSAAfter(37.47448996772893);
-    points.append(p);
+    points += VSAPoint(218.976377952756053, 134.488062992126459);
+    points += VSAPoint(218.976377952756053, 134.488062992126459);
+    points += VSAPoint(218.976377952756053, 134.488062992126459);
 
-    points.append(VSAPoint(218.97637795275605, 134.48806299212646));
-    points.append(VSAPoint(218.97637795275605, 134.48806299212646));
-    points.append(VSAPoint(218.97637795275605, 134.48806299212646));
+    p = VSAPoint(209.413110094717808, 142.833471271341665);
+    p.SetSABefore(35.5678);
+    p.SetSAAfter(35.5678);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(209.4131100947178, 142.83347127134166);
-    p.SetSABefore(35.567798456628196);
-    p.SetSAAfter(35.567798456628196);
-    points.append(p);
+    p = VSAPoint(197.174610917946893, 151.638887884599654);
+    p.SetSABefore(32.9219);
+    p.SetSAAfter(32.9219);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(197.1746109179469, 151.63888788459965);
-    p.SetSABefore(32.921869998532244);
-    p.SetSAAfter(32.921869998532244);
-    points.append(p);
+    p = VSAPoint(190.027023685018719, 155.744824719499547);
+    p.SetSABefore(31.4753);
+    p.SetSAAfter(31.4753);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(190.02702368501872, 155.74482471949955);
-    p.SetSABefore(31.47527442778118);
-    p.SetSAAfter(31.47527442778118);
-    points.append(p);
+    p = VSAPoint(183.690040040596074, 158.450531399325257);
+    p.SetSABefore(30.266);
+    p.SetSAAfter(30.266);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(183.69004004059607, 158.45053139932526);
-    p.SetSABefore(30.26604125961245);
-    p.SetSAAfter(30.26604125961245);
-    points.append(p);
+    p = VSAPoint(178.111093559349001, 159.860599171825072);
+    p.SetSABefore(29.2562);
+    p.SetSAAfter(29.2562);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(178.111093559349, 159.86059917182507);
-    p.SetSABefore(29.256179984052537);
-    p.SetSAAfter(29.256179984052537);
-    points.append(p);
+    p = VSAPoint(173.237617815947488, 160.079619284747537);
+    p.SetSABefore(28.4);
+    p.SetSAAfter(28.4);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(173.2376178159475, 160.07961928474754);
-    p.SetSABefore(28.40004977195057);
-    p.SetSAAfter(28.40004977195057);
-    points.append(p);
+    p = VSAPoint(169.017046385061462, 159.212182985841025);
+    p.SetSABefore(27.6439);
+    p.SetSAAfter(27.6439);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(169.01704638506146, 159.21218298584103);
-    p.SetSABefore(27.643881968500146);
-    p.SetSAAfter(27.643881968500146);
-    points.append(p);
+    p = VSAPoint(165.396812841360941, 157.362881522853911);
+    p.SetSABefore(26.9305);
+    p.SetSAAfter(26.9305);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(165.39681284136094, 157.3628815228539);
-    p.SetSABefore(26.930459398621437);
-    p.SetSAAfter(26.930459398621437);
-    points.append(p);
+    p = VSAPoint(162.324350759515880, 154.636306143534711);
+    p.SetSABefore(26.2096);
+    p.SetSAAfter(26.2096);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(162.32435075951588, 154.6363061435347);
-    p.SetSABefore(26.20955952854878);
-    p.SetSAAfter(26.20955952854878);
-    points.append(p);
+    p = VSAPoint(158.575695647501561, 149.207322310502946);
+    p.SetSABefore(25.0517);
+    p.SetSAAfter(25.0517);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(158.57569564750156, 149.20732231050295);
-    p.SetSABefore(25.05174589376139);
-    p.SetSAAfter(25.05174589376139);
-    points.append(p);
+    p = VSAPoint(155.086603150983990, 139.745623026852769);
+    p.SetSABefore(23.282);
+    p.SetSAAfter(23.282);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(155.086603150984, 139.74562302685277);
-    p.SetSABefore(23.28197087076461);
-    p.SetSAAfter(23.28197087076461);
-    points.append(p);
+    p = VSAPoint(152.842400845947793, 128.657470537345603);
+    p.SetSABefore(21.2966);
+    p.SetSAAfter(21.2966);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(152.8424008459478, 128.6574705373456);
-    p.SetSABefore(21.29660756707718);
-    p.SetSAAfter(21.29660756707718);
-    points.append(p);
+    p = VSAPoint(150.866158843535715, 110.747817409061298);
+    p.SetSABefore(18.1345);
+    p.SetSAAfter(18.1345);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(150.86615884353571, 110.7478174090613);
-    p.SetSABefore(18.1344895060695);
-    p.SetSAAfter(18.1344895060695);
-    points.append(p);
+    p = VSAPoint(149.373821053326026, 94.001593653555375);
+    p.SetSABefore(15.184);
+    p.SetSAAfter(15.184);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(149.37382105332603, 94.00159365355537);
-    p.SetSABefore(15.183977229796845);
-    p.SetSAAfter(15.183977229796845);
-    points.append(p);
+    p = VSAPoint(147.903865487813732, 84.774928160493630);
+    p.SetSABefore(13.5443);
+    p.SetSAAfter(13.5443);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(147.90386548781373, 84.77492816049363);
-    p.SetSABefore(13.544330017337995);
-    p.SetSAAfter(13.544330017337995);
-    points.append(p);
+    p = VSAPoint(145.576143100581845, 78.105459371511586);
+    p.SetSABefore(12.3046);
+    p.SetSAAfter(12.3046);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(145.57614310058185, 78.10545937151159);
-    p.SetSABefore(12.304638548569304);
-    p.SetSAAfter(12.304638548569304);
-    points.append(p);
+    p = VSAPoint(142.964662887243179, 75.410534564509078);
+    p.SetSABefore(11.6461);
+    p.SetSAAfter(11.6461);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(142.96466288724318, 75.41053456450908);
-    p.SetSABefore(11.646068510270936);
-    p.SetSAAfter(11.646068510270936);
-    points.append(p);
+    p = VSAPoint(140.763228387362460, 74.778132056190998);
+    p.SetSABefore(11.2441);
+    p.SetSAAfter(11.2441);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(140.76322838736246, 74.778132056191);
-    p.SetSABefore(11.244104436407117);
-    p.SetSAAfter(11.244104436407117);
-    points.append(p);
+    p = VSAPoint(138.110803268066746, 75.255689338760732);
+    p.SetSABefore(10.7711);
+    p.SetSAAfter(10.7711);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(138.11080326806675, 75.25568933876073);
-    p.SetSABefore(10.771134584490436);
-    p.SetSAAfter(10.771134584490436);
-    points.append(p);
+    p = VSAPoint(134.954821104026024, 76.947797659966710);
+    p.SetSABefore(10.1427);
+    p.SetSAAfter(10.1427);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(134.95482110402602, 76.94779765996671);
-    p.SetSABefore(10.142692312810262);
-    p.SetSAAfter(10.142692312810262);
-    points.append(p);
+    p = VSAPoint(129.241060982167369, 81.807533048917350);
+    p.SetSABefore(8.82632);
+    p.SetSAAfter(8.82632);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    p = VSAPoint(129.24106098216737, 81.80753304891735);
-    p.SetSABefore(8.826320717353354);
-    p.SetSAAfter(8.826320717353354);
-    points.append(p);
+    p = VSAPoint(124.488188976378183, 87.243968503937310);
+    p.SetSABefore(7.55906);
+    points += p;
 
-    p = VSAPoint(124.48818897637818, 87.24396850393731);
-    p.SetSABefore(7.559055118110236);
-    points.append(p);
+    p = VSAPoint(124.488188976378183, 87.243968503937310);
+    p.SetSABefore(7.55906);
+    points += p;
 
-    p = VSAPoint(124.48818897637818, 87.24396850393731);
-    p.SetSABefore(7.559055118110236);
-    points.append(p);
+    p = VSAPoint(124.488188976378183, 87.243968503937310);
+    p.SetSABefore(7.55906);
+    points += p;
 
-    p = VSAPoint(124.48818897637818, 87.24396850393731);
-    p.SetSABefore(7.559055118110236);
-    points.append(p);
+    p = VSAPoint(118.347357299687616, 94.279895957313556);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
 
-    points.append(VSAPoint(118.34735729968762, 94.27989595731356));
-    points.append(VSAPoint(106.58315141316105, 104.8247018186949));
-    points.append(VSAPoint(95.47573767084238, 111.51940225476525));
-    points.append(VSAPoint(85.06494183271205, 114.78883440900722));
-    points.append(VSAPoint(75.39058965875054, 115.05783542490349));
-    points.append(VSAPoint(66.49250690893827, 112.7512424459367));
-    points.append(VSAPoint(58.410519343255714, 108.29389261558948));
-    points.append(VSAPoint(51.184452721683314, 102.11062307734451));
-    points.append(VSAPoint(44.85413280420151, 94.62627097468442));
-    points.append(VSAPoint(39.45938535079078, 86.26567345109187));
-    points.append(VSAPoint(35.04003612143157, 77.45366765004948));
-    points.append(VSAPoint(31.63591087610432, 68.61509071503997));
-    points.append(VSAPoint(29.286835374789483, 60.17477978954592));
-    points.append(VSAPoint(28.032635377467525, 52.55757201704999));
-    points.append(VSAPoint(27.913136644118886, 46.188304541034846));
-    points.append(VSAPoint(28.968164934724022, 41.49181450498314));
-    points.append(VSAPoint(30.0, 39.999874015748034));
+    p = VSAPoint(106.583151413161048, 104.824701818694905);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(95.475737670842378, 111.519402254765254);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(85.064941832712051, 114.788834409007222);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(75.390589658750542, 115.057835424903487);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(66.492506908938267, 112.751242445936697);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(58.410519343255714, 108.293892615589485);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(51.184452721683314, 102.110623077344513);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(44.854132804201512, 94.626270974684417);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(39.459385350790782, 86.265673451091871);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(35.040036121431569, 77.453667650049482);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(31.635910876104319, 68.615090715039969);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(29.286835374789483, 60.174779789545923);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(28.032635377467525, 52.557572017049992);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(27.913136644118886, 46.188304541034846);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    p = VSAPoint(28.968164934724022, 41.491814504983139);
+    p.SetAngleType(PieceNodeAngle::ByLengthCurve);
+    points += p;
+
+    points += VSAPoint(30.000000000000000, 39.999874015748034);
 
     return points;
 }
@@ -2724,7 +2819,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsCase3() const
     points += QPointF(287.082912046801141, 210.253300532205827);
     points += QPointF(288.703123507393855, 195.143319989158869);
     points += QPointF(293.166186492321515, 180.515626372699529);
-    points += QPointF(295.750834317039335, 175.266984212723173);
+    points += QPointF(295.670561165402944, 175.368662126210381);
     points += QPointF(297.032789141387639, 169.787277456273927);
     points += QPointF(298.427265336435482, 158.085347733237541);
     points += QPointF(297.942252974132145, 150.956565035035396);
@@ -2734,14 +2829,15 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsCase3() const
     points += QPointF(290.481153622471652, 145.599128854247056);
     points += QPointF(285.006529976725062, 145.720902585837194);
     points += QPointF(278.361635788833837, 146.694970613418548);
-    points += QPointF(267.519968122858188, 149.956925613013397);
+    points += QPointF(271.146419906629319, 148.487066701674678);
     points += QPointF(264.113564564717535, 150.863468795615489);
     points += QPointF(254.197633499102608, 155.207693600770455);
     points += QPointF(247.566503205391086, 159.218808117984338);
-    points += QPointF(242.133205734663164, 164.068016868286207);
+    points += QPointF(246.254288772883399, 160.259875418548035);
+    points += QPointF(243.533064986225241, 163.142629256756265);
     points += QPointF(226.130506064139297, 173.663708795026963);
     points += QPointF(209.783463599772517, 181.559396073216902);
-    points += QPointF(204.008719733376893, 183.449807040567407);
+    points += QPointF(198.870332140896153, 185.514532456989372);
     points += QPointF(188.212417365369049, 188.007916133837341);
     points += QPointF(177.315021813262121, 188.814025605756967);
     points += QPointF(166.192147226980524, 187.373264242432697);
@@ -2761,8 +2857,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsCase3() const
     points += QPointF(14.420075278530305, 117.169833926538999);
     points += QPointF(6.592092174103988, 105.038289915852545);
     points += QPointF(0.431098196206621, 92.753514068597141);
-    points += QPointF(-3.811839725119704, 80.407158989437562);
-    points += QPointF(-7.160548513622416, 68.341960678446355);
+    points += QPointF(-4.287700865002472, 80.501477043638104);
+    points += QPointF(-7.673598677574617, 68.335827074506327);
     points += QPointF(-9.704701735666340, 56.000207529081479);
     points += QPointF(-9.960881193587724, 42.345874603213382);
     points += QPointF(-6.297329478268652, 26.037464411020956);
@@ -2836,24 +2932,24 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue627() const
 
     points += QPointF(11561.415478724189597, -14.638641388671703);
     points += QPointF(11760.258895120205125, -3158.713169528752587);
-    points += QPointF(11781.996734110334728, -3502.427772226710658);
-    points += QPointF(11867.496139886348828, -3648.194635075343740);
-    points += QPointF(11962.154877960796512, -3812.801737355388468);
-    points += QPointF(12058.281041510977957, -3980.811598798730756);
-    points += QPointF(12156.222991903809088, -4153.718629724788116);
-    points += QPointF(12257.041160881331962, -4332.593222274457730);
-    points += QPointF(12413.634876614758468, -4614.375203387230613);
-    points += QPointF(12638.875580780275413, -5024.643354851166805);
-    points += QPointF(12887.730780405261612, -5482.200047474014355);
-    points += QPointF(13313.529827372416548, -6270.219194236016847);
+    points += QPointF(11781.963905683212943, -3501.908695340060603);
+    points += QPointF(11867.565752333255659, -3648.313692662954054);
+    points += QPointF(11962.607394275857587, -3812.694206301280701);
+    points += QPointF(12058.712075176787039, -3980.708890064594925);
+    points += QPointF(12156.626721853161143, -4153.621262002729964);
+    points += QPointF(12257.097609428719807, -4332.693831870464237);
+    points += QPointF(12413.705754675855133, -4614.502744651450485);
+    points += QPointF(12638.929472529416671, -5024.741516808088818);
+    points += QPointF(12887.767807606705901, -5482.268127401037418);
+    points += QPointF(13313.547415030390766, -6270.251743419321429);
     points += QPointF(13707.971545534986944, -7002.489438444617917);
     points += QPointF(13491.504163312642049, -14.778496052733317);
-    points += QPointF(13226.693612049832154, -21.703416545128476);
+    points += QPointF(13226.486095144688079, -21.708843209821751);
     points += QPointF(12939.151113441983398, -27.115981224805608);
     points += QPointF(12664.386257521342486, -29.821358267716541);
     points += QPointF(12393.881459014091888, -29.821358267716541);
     points += QPointF(12119.116603093452795, -27.115981224805608);
-    points += QPointF(11831.574104485600401, -21.703416545128452);
+    points += QPointF(11831.366553404686783, -21.699509701252438);
     points += QPointF(11561.415478724189597, -14.638641388671703);
 
     return points;
@@ -3163,44 +3259,43 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue767_Fabric_TopCollar() con
 
     points += QPointF(-3011.051754879010332, -958.321944400611301);
     points += QPointF(-2875.704655596311113, -988.873180340485987);
-    points += QPointF(-2869.673059677899346, -996.524365493772848);
+    points += QPointF(-2870.266139694495905, -995.294853951866457);
     points += QPointF(-2852.541502402287279, -1017.672534874126313);
     points += QPointF(-2834.561736510239371, -1042.007683734111424);
     points += QPointF(-2816.318152801346969, -1068.219702443143433);
     points += QPointF(-2788.352030367969292, -1110.859883556803652);
-    points += QPointF(-2749.386875540295023, -1175.765108151581899);
-    points += QPointF(-2735.802578699315291, -1198.692835538001191);
-    points += QPointF(-2709.397930307027764, -1242.234412525293919);
-    points += QPointF(-2667.715543026665728, -1313.946271185688829);
-    points += QPointF(-2603.712719729991932, -1428.363509653913525);
-    points += QPointF(-2559.695881072102566, -1507.019334818998004);
-    points += QPointF(-2514.669030745282726, -1585.102888953246520);
+    points += QPointF(-2750.104578133508312, -1173.706685440264437);
+    points += QPointF(-2709.576301328694626, -1242.298707376999573);
+    points += QPointF(-2667.685724118163762, -1313.999219737975636);
+    points += QPointF(-2603.306990389053681, -1428.314629665485654);
+    points += QPointF(-2559.715942725519653, -1507.018455323058788);
+    points += QPointF(-2514.227494695693167, -1585.119667416120365);
     points += QPointF(-2449.158395429499251, -1698.662018272644673);
     points += QPointF(-2408.901620525934959, -1771.183767809588062);
-    points += QPointF(-2385.019807124009731, -1816.159092763202125);
-    points += QPointF(-2372.278829778459112, -1839.571054304704830);
+    points += QPointF(-2384.845551286147384, -1816.215840001470042);
+    points += QPointF(-2370.880345941558971, -1841.237056353140815);
     points += QPointF(-2336.479706267199163, -1906.269233768278809);
     points += QPointF(-2314.171878902582193, -1952.123894247253929);
     points += QPointF(-2300.997366939366657, -1981.215654350529348);
     points += QPointF(-2289.299963085878971, -2009.119815234373618);
-    points += QPointF(-2279.904176693012232, -2034.668560352101622);
+    points += QPointF(-2279.153348206748888, -2035.802573282930325);
     points += QPointF(-2276.421885291452327, -2043.762124623026239);
     points += QPointF(-2319.478871757543402, -2175.664782739318980);
     points += QPointF(-2117.171449255143671, -2194.168101599941110);
     points += QPointF(-2068.215402990954772, -2065.277909112684483);
-    points += QPointF(-1952.636612250339113, -1890.801040797071892);
+    points += QPointF(-1952.636614028386703, -1890.801039106245071);
     points += QPointF(-1917.586670824047815, -1837.889915684416337);
-    points += QPointF(-2058.290157817677482, -1695.288962930576417);
-    points += QPointF(-2088.496544359629297, -1664.658274581629485);
-    points += QPointF(-2140.249137288813927, -1608.813882325172699);
-    points += QPointF(-2176.258901095932742, -1568.108510006007918);
+    points += QPointF(-2058.560149041760724, -1695.491664502713775);
+    points += QPointF(-2088.680400307789114, -1664.468919112514186);
+    points += QPointF(-2140.427345188782056, -1608.621584484509185);
+    points += QPointF(-2176.442570235218682, -1567.900890740904742);
     points += QPointF(-2212.334254034449714, -1525.262668863119416);
     points += QPointF(-2247.234202528754395, -1481.174098429168680);
     points += QPointF(-2279.766629673790248, -1436.693272413116574);
     points += QPointF(-2301.715318706475500, -1403.691786696854933);
-    points += QPointF(-2314.880004231360545, -1381.841888079642331);
-    points += QPointF(-2321.059426304634599, -1371.449590621683228);
-    points += QPointF(-2326.823644233704272, -1360.817879791030009);
+    points += QPointF(-2315.030637739082067, -1382.066893805181053);
+    points += QPointF(-2321.200039954151634, -1371.365087899206856);
+    points += QPointF(-2327.092357559710763, -1360.835222350091499);
     points += QPointF(-2338.849983413490008, -1338.325403429812241);
     points += QPointF(-2355.959416743849943, -1302.574734893039931);
     points += QPointF(-2377.510297026410626, -1251.855288345610234);
@@ -3208,9 +3303,9 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue767_Fabric_TopCollar() con
     points += QPointF(-2415.844466989297416, -1146.377438809215619);
     points += QPointF(-2432.371872429092036, -1094.604132032660573);
     points += QPointF(-2453.842769979148215, -1021.556698266764784);
-    points += QPointF(-2464.688086893720538, -979.925175945867977);
+    points += QPointF(-2465.056142821574667, -979.842028311906802);
     points += QPointF(-2515.136197939204976, -786.051916914061394);
-    points += QPointF(-2578.531707943902347, -789.067686454400928);
+    points += QPointF(-2578.531709722424239, -789.067688957792370);
     points += QPointF(-2787.581316069136847, -799.012322645365543);
     points += QPointF(-2923.361187022479953, -775.070667959158072);
     points += QPointF(-3011.051754879010332, -958.321944400611301);
@@ -3518,31 +3613,31 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue767_SkinFusing_TopCollar_N
 
     points += QPointF(-2956.503052984476199, -931.888772536086435);
     points += QPointF(-2845.899935373787230, -956.854671027579229);
-    points += QPointF(-2836.829206609389075, -967.939801293693108);
-    points += QPointF(-2817.847448769272432, -991.136726507765957);
-    points += QPointF(-2798.925476794025144, -1016.464369774690340);
-    points += QPointF(-2779.833540165219802, -1043.586706230470554);
-    points += QPointF(-2750.887165791067218, -1087.214110077616169);
-    points += QPointF(-2711.656875795550150, -1150.911108576494144);
-    points += QPointF(-2671.760583609896912, -1219.742470238479427);
-    points += QPointF(-2631.217741006335018, -1292.785732104274075);
-    points += QPointF(-2569.371672884839427, -1408.673435611815421);
-    points += QPointF(-2526.833380893804133, -1488.350137219814769);
-    points += QPointF(-2480.172583413850589, -1565.686358992571968);
-    points += QPointF(-2412.294561879652520, -1678.145787075361113);
-    points += QPointF(-2370.310678852975343, -1750.370393382875818);
-    points += QPointF(-2331.613674911975522, -1819.883071107430624);
-    points += QPointF(-2296.985964337713085, -1886.194796550727006);
-    points += QPointF(-2274.332039896478364, -1933.396943358504132);
-    points += QPointF(-2260.809956115590921, -1963.683515123610960);
-    points += QPointF(-2248.742446883836237, -1992.905181021183125);
-    points += QPointF(-2238.534158510385168, -2021.092198893151817);
+    points += QPointF(-2836.585168992718536, -967.735542343798102);
+    points += QPointF(-2817.807710164808213, -991.186353033625323);
+    points += QPointF(-2798.863899498001501, -1016.546792885192417);
+    points += QPointF(-2779.749114651553100, -1043.706642580126527);
+    points += QPointF(-2750.758655190988520, -1087.407798716331399);
+    points += QPointF(-2711.491790104854317, -1151.179153064404545);
+    points += QPointF(-2671.741745541462024, -1220.149721048735501);
+    points += QPointF(-2630.984188137075762, -1293.204742264258130);
+    points += QPointF(-2569.022589526747197, -1408.526088240801528);
+    points += QPointF(-2526.849928574272781, -1488.355444559092348);
+    points += QPointF(-2479.812157489062429, -1565.559731854928032);
+    points += QPointF(-2412.442076435102535, -1677.899792577346261);
+    points += QPointF(-2370.412668357553684, -1750.194941488371569);
+    points += QPointF(-2331.673284372557191, -1819.775992708568765);
+    points += QPointF(-2297.016687030217327, -1886.135962896511273);
+    points += QPointF(-2274.355914702014616, -1933.347197360681321);
+    points += QPointF(-2260.825261304527430, -1963.649234778169330);
+    points += QPointF(-2248.749446962910497, -1992.888230218159833);
+    points += QPointF(-2238.231008875008683, -2020.995791005643241);
     points += QPointF(-2233.658271705575316, -2034.554538661309380);
     points += QPointF(-2268.843635583416926, -2142.342923385616359);
     points += QPointF(-2142.312261122111522, -2153.915659267328920);
     points += QPointF(-2102.051574703390088, -2047.918381746697833);
     points += QPointF(-1957.540323165073914, -1829.765289335081889);
-    points += QPointF(-2074.437778770928162, -1711.210902701150189);
+    points += QPointF(-2074.675746476507811, -1711.446016505494981);
     points += QPointF(-2104.950100513636244, -1680.266092395088435);
     points += QPointF(-2157.060300446018118, -1624.035819072004870);
     points += QPointF(-2193.427447844696871, -1582.926460982949266);
@@ -3550,9 +3645,9 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue767_SkinFusing_TopCollar_N
     points += QPointF(-2265.283071500467031, -1494.910143892727319);
     points += QPointF(-2298.369042538657141, -1449.672470270627628);
     points += QPointF(-2320.817401374072688, -1415.919693858456867);
-    points += QPointF(-2334.301819293990775, -1393.548592491243653);
-    points += QPointF(-2340.776926411613658, -1382.651109181193078);
-    points += QPointF(-2346.823691803941529, -1371.506749034128916);
+    points += QPointF(-2334.512979024599190, -1393.677237702732782);
+    points += QPointF(-2340.846420578639481, -1382.690879565373507);
+    points += QPointF(-2347.040624073485560, -1371.625420238929109);
     points += QPointF(-2359.134023973919739, -1348.472766354998839);
     points += QPointF(-2376.632959709957049, -1311.908220986026436);
     points += QPointF(-2398.550531297711586, -1260.325775813514156);
@@ -3560,7 +3655,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue767_SkinFusing_TopCollar_N
     points += QPointF(-2437.363294145462532, -1153.537798188641318);
     points += QPointF(-2454.054727973233639, -1101.250660485525259);
     points += QPointF(-2475.673988008996275, -1027.698473771005865);
-    points += QPointF(-2486.632484779730930, -985.643325115674202);
+    points += QPointF(-2486.955875679277597, -985.728923017021771);
     points += QPointF(-2528.614214395534418, -824.531092595292307);
     points += QPointF(-2789.994527521454074, -836.965136994369914);
     points += QPointF(-2901.657768807878711, -817.275894802197854);
@@ -3689,16 +3784,16 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue880_Piece_Detail() const
     QVector<QPointF> points;
 
     points += QPointF(207.975244350313460, 1768.545187243969849);
-    points += QPointF(192.251204248591591, 1678.402467017463778);
-    points += QPointF(173.441824083164022, 1567.217943760191474);
-    points += QPointF(155.417517581674048, 1456.936677653171955);
-    points += QPointF(137.953198930131180, 1347.590985755569136);
+    points += QPointF(192.052357429286502, 1678.591759717724699);
+    points += QPointF(173.066378231393685, 1567.418836695434493);
+    points += QPointF(155.048521972231981, 1457.132094707775423);
+    points += QPointF(137.977104738153116, 1347.744174880447417);
     points += QPointF(113.948652961709485, 1185.025355945024330);
     points += QPointF(85.132622460042427, 971.275956770753282);
     points += QPointF(59.563338142961662, 760.511333975782236);
-    points += QPointF(37.005263804531687, 552.491340651303972);
-    points += QPointF(17.219790912506401, 346.953909184687859);
-    points += QPointF(-0.029116486330288, 143.668419233907429);
+    points += QPointF(37.029820911080137, 552.717794783143404);
+    points += QPointF(17.240286265801252, 347.166821066865964);
+    points += QPointF(-0.015008757567600, 143.834684637698103);
     points += QPointF(-12.288070724611142, -17.710595485938104);
     points += QPointF(26.316659671669068, -20.643155361401121);
     points += QPointF(45.449182757960564, -46.830007644639885);
@@ -3716,8 +3811,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue880_Piece_Detail() const
     points += QPointF(438.307932392301666, -289.135939110304264);
     points += QPointF(472.431670530633255, -289.352342269912128);
     points += QPointF(506.393547409497444, -287.069334621112432);
-    points += QPointF(523.659788432941014, -284.763366956816640);
-    points += QPointF(537.132657080684112, -282.447979406543027);
+    points += QPointF(523.743301608497973, -284.906308037942438);
+    points += QPointF(536.868759697778614, -282.972642447483622);
     points += QPointF(561.258611782860839, -277.900419936185699);
     points += QPointF(584.473517653931367, -271.240539453433826);
     points += QPointF(606.329115257862554, -263.093202286243240);
@@ -3731,7 +3826,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue880_Piece_Detail() const
     points += QPointF(736.508892979171492, -156.650006278643616);
     points += QPointF(753.948152387964797, -131.655764206155084);
     points += QPointF(775.231449650412515, -96.860472475085288);
-    points += QPointF(804.510801021029010, -43.194675282815112);
+    points += QPointF(804.659958042692779, -43.462597316917439);
     points += QPointF(834.310499706231440, 11.429285555756231);
     points += QPointF(855.028099173095029, 47.205385464279573);
     points += QPointF(877.561104827702366, 82.245582223782790);
@@ -3740,9 +3835,9 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue880_Piece_Detail() const
     points += QPointF(923.186035221141992, 140.007722295159482);
     points += QPointF(938.093299030574826, 155.551520058117717);
     points += QPointF(954.013080954349675, 170.591351779598710);
-    points += QPointF(967.555698092657849, 181.751643909074176);
-    points += QPointF(1004.158461523971027, 191.170803434049844);
-    points += QPointF(989.262064918097849, 250.007556316099055);
+    points += QPointF(967.478282407841220, 182.052480516597853);
+    points += QPointF(1004.081045839154399, 191.471640041573494);
+    points += QPointF(988.997625529862603, 250.085666468473050);
     points += QPointF(977.825907073445137, 296.824101606491240);
     points += QPointF(965.149517480306031, 354.356952623703251);
     points += QPointF(951.501406931069596, 421.671630375482096);
@@ -3753,7 +3848,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue880_Piece_Detail() const
     points += QPointF(887.467042701909804, 868.464429717168059);
     points += QPointF(879.223426160358372, 972.660783700921684);
     points += QPointF(874.920744508827170, 1052.548385015779559);
-    points += QPointF(873.401191077498538, 1106.279226085242499);
+    points += QPointF(872.967477678962268, 1106.266056241682008);
     points += QPointF(871.864931939666576, 1160.331215197386200);
     points += QPointF(871.679638670957502, 1214.566973456243431);
     points += QPointF(872.476082054519338, 1268.842132890775247);
@@ -3935,10 +4030,10 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue880_Piece_Detail_1() const
     points += QPointF(684.751653548328704, 233.160921516904352);
     points += QPointF(703.633355735262512, 217.521328821535519);
     points += QPointF(722.259991845816671, 200.384439254023107);
-    points += QPointF(740.836644528519173, 180.911600318108782);
+    points += QPointF(740.775593812870966, 181.547299114609586);
     points += QPointF(827.890520660986795, 85.404756544033887);
     points += QPointF(902.528765906973376, 97.365683534123988);
-    points += QPointF(875.376910079016625, 265.121443536514221);
+    points += QPointF(875.674633126301046, 264.940098963036405);
     points += QPointF(858.006688452906701, 367.901611578837674);
     points += QPointF(840.922428439775899, 473.994397066476608);
     points += QPointF(828.863202448516518, 555.064398169016044);
@@ -3948,7 +4043,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue880_Piece_Detail_1() const
     points += QPointF(785.781431600197493, 947.468510425481782);
     points += QPointF(778.990524885403715, 1057.201556595780858);
     points += QPointF(775.712914874765261, 1141.172167796453323);
-    points += QPointF(774.839277375508800, 1197.529933383505750);
+    points += QPointF(774.416545265376726, 1197.523302280107373);
     points += QPointF(773.947565414695873, 1254.216246927699785);
     points += QPointF(774.372593569917512, 1311.026601052771866);
     points += QPointF(775.755623649198697, 1367.813432350162429);
@@ -3956,7 +4051,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue880_Piece_Detail_1() const
     points += QPointF(781.647320084431385, 1480.749273059121151);
     points += QPointF(786.279070102662104, 1536.612815122052325);
     points += QPointF(792.114529969787213, 1591.881891902256712);
-    points += QPointF(799.671600568179883, 1646.800706819577044);
+    points += QPointF(799.233464070713808, 1646.581496557790842);
     points += QPointF(815.482414590454709, 1753.334844240462417);
     points += QPointF(176.433003213139955, 1809.244423168889170);
 
@@ -5754,7 +5849,7 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue298Case1() const
 
     points += QPointF(1181.370211203355211, -59.406362870594705);
     points += QPointF(1269.039464046917146, 38.629190783372337);
-    points += QPointF(1217.450644318709010, 100.120104210239219);
+    points += QPointF(1216.924519205873821, 100.217664911215365);
     points += QPointF(1198.880813132726189, 123.039801916996382);
     points += QPointF(1182.221067861893971, 145.936740845325801);
     points += QPointF(1166.732941367353760, 169.110459436420683);
@@ -5765,8 +5860,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue298Case1() const
     points += QPointF(1105.068527046499639, 289.339750389149117);
     points += QPointF(1095.565711567573317, 314.297220920440736);
     points += QPointF(1086.908151663856643, 339.567011965302527);
-    points += QPointF(1079.478145695263947, 365.275940243457455);
-    points += QPointF(1072.378301707078663, 391.150604919231398);
+    points += QPointF(1079.057194431329890, 365.149542878958755);
+    points += QPointF(1071.975242726907936, 391.043344437292944);
     points += QPointF(1065.665089220277650, 417.081281156897660);
     points += QPointF(1057.340196822427288, 456.975106162385032);
     points += QPointF(1048.568245158969830, 511.317285018278824);
@@ -5774,8 +5869,8 @@ QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue298Case1() const
     points += QPointF(1037.578000765741308, 622.844551248912239);
     points += QPointF(1034.714937128092288, 680.001664325593765);
     points += QPointF(1033.177151285076661, 737.946609060597439);
-    points += QPointF(1033.070378460275606, 796.430233334258673);
-    points += QPointF(1033.028555453234048, 885.654637352061627);
+    points += QPointF(1032.630068889550103, 796.521290449247772);
+    points += QPointF(1032.895861058649189, 885.767291298921236);
     points += QPointF(1033.622065798040012, 991.890644345887608);
     points += QPointF(940.875971287879679, 1031.297840617347674);
     points += QPointF(376.989021179537758, 480.040217570165055);