aw/valentina
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added class VAbstractPiece.

Browse Source 
--HG--
branch : feature
This commit is contained in:
Roman Telezhynskyi 2016-11-03 20:15:53 +02:00
parent 27d6198657
commit 22f9fb1e26
5 changed files with 491 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

301
src/libs/vlayout/vabstractpiece.cpp Normal file
View File

@ -0,0 +1,301 @@
/************************************************************************
**
** @file
** @author Roman Telezhynskyi <dismine(at)gmail.com>
** @date 3 11, 2016
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2016 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** Valentina is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#include "vabstractpiece.h"
#include <QLineF>
#include <QSet>
#include <QVector>
#include <QDebug>
#include "../vgeometry/vgobject.h"
//---------------------------------------------------------------------------------------------------------------------
VAbstractPiece::VAbstractPiece()
{}
//---------------------------------------------------------------------------------------------------------------------
VAbstractPiece::VAbstractPiece(const VAbstractPiece &piece)
{
Q_UNUSED(piece)
}
//---------------------------------------------------------------------------------------------------------------------
VAbstractPiece &VAbstractPiece::operator=(const VAbstractPiece &piece)
{
if ( &piece == this )
{
return *this;
}
return *this;
}
//---------------------------------------------------------------------------------------------------------------------
VAbstractPiece::~VAbstractPiece()
{}
//---------------------------------------------------------------------------------------------------------------------
qreal VAbstractPiece::SumTrapezoids(const QVector<QPointF> &points)
{
// Calculation a polygon area through the sum of the areas of trapezoids
qreal s, res = 0;
const int n = points.size();
if(n > 2)
{
for (int i = 0; i < n; ++i)
{
if (i == 0)
{
//if i == 0, then y[i-1] replace on y[n-1]
s = points.at(i).x()*(points.at(n-1).y() - points.at(i+1).y());
res += s;
}
else
{
if (i == n-1)
{
// if i == n-1, then y[i+1] replace on y[0]
s = points.at(i).x()*(points.at(i-1).y() - points.at(0).y());
res += s;
}
else
{
s = points.at(i).x()*(points.at(i-1).y() - points.at(i+1).y());
res += s;
}
}
}
}
return res;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief CheckLoops seek and delete loops in equidistant.
* @param points vector of points of equidistant.
* @return vector of points of equidistant.
*/
QVector<QPointF> VAbstractPiece::CheckLoops(const QVector<QPointF> &points)
{
const int count = points.size();
/*If we got less than 4 points no need seek loops.*/
if (count < 4)
{
qDebug()<<"Less then 4 points. Doesn't need check for loops.";
return points;
}
const bool pathClosed = (points.first() == points.last());
QVector<QPointF> ekvPoints;
qint32 i, j, jNext = 0;
for (i = 0; i < count; ++i)
{
/*Last three points no need check.*/
/*Triangle has not contain loops*/
if (i > count-3)
{
ekvPoints.append(points.at(i));
continue;
}
enum LoopIntersectType { NoIntersection, BoundedIntersection, ParallelIntersection };
QPointF crosPoint;
LoopIntersectType status = NoIntersection;
const QLineF line1(points.at(i), points.at(i+1));
// Because a path can contains several loops we will seek the last and only then remove the loop(s)
// That's why we parse from the end
for (j = count-1; j >= i+2; --j)
{
j == count-1 ? jNext = 0 : jNext = j+1;
QLineF line2(points.at(j), points.at(jNext));
if(qFuzzyIsNull(line2.length()))
{//If a path is closed the edge (count-1;0) length will be 0
continue;
}
QSet<qint32> uniqueVertices;
uniqueVertices << i << i+1 << j;
// For closed path last point is equal to first. Using index of the first.
pathClosed && jNext == count-1 ? uniqueVertices << 0 : uniqueVertices << jNext;
const QLineF::IntersectType intersect = line1.intersect(line2, &crosPoint);
if (intersect == QLineF::NoIntersection)
{ // According to the documentation QLineF::NoIntersection indicates that the lines do not intersect;
// i.e. they are parallel. But parallel also mean they can be on the same line.
// Method IsPointOnLineviaPDP will check it.
if (VGObject::IsPointOnLineviaPDP(points.at(j), points.at(i), points.at(i+1))
// Lines are not neighbors
&& uniqueVertices.size() == 4
&& line1.p2() != line2.p2()
&& line1.p1() != line2.p1()
&& line1.p2() != line2.p1()
&& line1.p1() != line2.p2())
{
// Left to catch case where segments are on the same line, but do not have real intersections.
QLineF tmpLine1 = line1;
QLineF tmpLine2 = line2;
tmpLine1.setAngle(tmpLine1.angle()+90);
QPointF tmpCrosPoint;
const QLineF::IntersectType tmpIntrs1 = tmpLine1.intersect(tmpLine2, &tmpCrosPoint);
tmpLine1 = line1;
tmpLine2.setAngle(tmpLine2.angle()+90);
const QLineF::IntersectType tmpIntrs2 = tmpLine1.intersect(tmpLine2, &tmpCrosPoint);
if (tmpIntrs1 == QLineF::BoundedIntersection || tmpIntrs2 == QLineF::BoundedIntersection)
{ // Now we really sure that lines are on the same lines and have real intersections.
status = ParallelIntersection;
break;
}
}
}
else if (intersect == QLineF::BoundedIntersection)
{
if (uniqueVertices.size() == 4
&& line1.p1() != crosPoint
&& line1.p2() != crosPoint
&& line2.p1() != crosPoint
&& line2.p2() != crosPoint)
{ // Break, but not if lines are neighbors
status = BoundedIntersection;
break;
}
}
status = NoIntersection;
}
switch (status)
{
case ParallelIntersection:
/*We have found a loop.*/
// Theoretically there is no big difference which point j or jNext to select.
// In the end we will draw a line in any case.
ekvPoints.append(points.at(i));
ekvPoints.append(points.at(jNext));
i = j;
break;
case BoundedIntersection:
/*We have found a loop.*/
ekvPoints.append(points.at(i));
ekvPoints.append(crosPoint);
i = j;
break;
case NoIntersection:
/*We have not found loop.*/
ekvPoints.append(points.at(i));
break;
default:
break;
}
}
return ekvPoints;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief CorrectEquidistantPoints clear equivalent points and remove point on line from equdistant.
* @param points list of points equdistant.
* @return corrected list.
*/
QVector<QPointF> VAbstractPiece::CorrectEquidistantPoints(const QVector<QPointF> &points, bool removeFirstAndLast)
{
if (points.size()<4)//Better don't check if only three points. We can destroy equidistant.
{
qDebug()<<"Only three points.";
return points;
}
//Clear equivalent points
QVector<QPointF> correctPoints = RemoveDublicates(points, removeFirstAndLast);
if (correctPoints.size()<3)
{
return correctPoints;
}
//Remove point on line
for (qint32 i = 1; i <correctPoints.size()-1; ++i)
{// In this case we alwayse will have bounded intersection, so all is need is to check if point i is on line.
// Unfortunatelly QLineF::intersect can't be used in this case because of the floating-point accuraccy problem.
if (VGObject::IsPointOnLineviaPDP(correctPoints.at(i), correctPoints.at(i-1), correctPoints.at(i+1)))
{
correctPoints.remove(i);
}
}
return correctPoints;
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VAbstractPiece::RemoveDublicates(const QVector<QPointF> &points, bool removeFirstAndLast)
{
QVector<QPointF> p = points;
if (removeFirstAndLast)
{
if (not p.isEmpty() && p.size() > 1)
{
// Path can't be closed
if (p.first() == p.last())
{
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
p.remove(p.size() - 1);
#else
p.removeLast();
#endif
}
}
}
for (int i = 0; i < p.size()-1; ++i)
{
if (p.at(i) == p.at(i+1))
{
if (not removeFirstAndLast && (i == p.size()-1))
{
continue;
}
p.erase(p.begin() + i + 1);
--i;
continue;
}
}
return p;
}

53
src/libs/vlayout/vabstractpiece.h Normal file
View File

@ -0,0 +1,53 @@
/************************************************************************
**
** @file
** @author Roman Telezhynskyi <dismine(at)gmail.com>
** @date 3 11, 2016
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2016 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** Valentina is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#ifndef VABSTRACTPIECE_H
#define VABSTRACTPIECE_H
#include <QtGlobal>
template <class T> class QVector;
class QPointF;
class VAbstractPiece
{
public:
VAbstractPiece();
VAbstractPiece(const VAbstractPiece &piece);
VAbstractPiece &operator=(const VAbstractPiece &piece);
virtual ~VAbstractPiece();
static qreal SumTrapezoids(const QVector<QPointF> &points);
static QVector<QPointF> CheckLoops(const QVector<QPointF> &points);
static QVector<QPointF> CorrectEquidistantPoints(const QVector<QPointF> &points, bool removeFirstAndLast = true);
protected:
static QVector<QPointF> RemoveDublicates(const QVector<QPointF> &points, bool removeFirstAndLast = true);
};
#endif // VABSTRACTPIECE_H

10
src/libs/vlayout/vlayout.pri
View File

@ -17,8 +17,9 @@ HEADERS += \
$$PWD/vbestsquare.h \
$$PWD/vposition.h \
$$PWD/vtextmanager.h \
vposter.h \
vgraphicsfillitem.h
$$PWD/vposter.h \
$$PWD/vgraphicsfillitem.h \
$$PWD/vabstractpiece.h
SOURCES += \
$$PWD/vlayoutgenerator.cpp \
@ -30,7 +31,8 @@ SOURCES += \
$$PWD/vbestsquare.cpp \
$$PWD/vposition.cpp \
$$PWD/vtextmanager.cpp \
vposter.cpp \
vgraphicsfillitem.cpp
$$PWD/vposter.cpp \
$$PWD/vgraphicsfillitem.cpp \
$$PWD/vabstractpiece.cpp
win32-msvc*:SOURCES += $$PWD/stable.cpp

121
src/libs/vpatterndb/vpiece.cpp
View File

@ -28,15 +28,21 @@
#include "vpiece.h"
#include "vpiece_p.h"
#include "../vgeometry/vpointf.h"
#include "../vgeometry/vabstractcurve.h"
#include "vcontainer.h"
#include <QSharedPointer>
#include <QDebug>
//---------------------------------------------------------------------------------------------------------------------
VPiece::VPiece()
: d(new VPieceData)
: VAbstractPiece(), d(new VPieceData)
{}
//---------------------------------------------------------------------------------------------------------------------
VPiece::VPiece(const VPiece &piece)
: d (piece.d)
: VAbstractPiece(piece), d (piece.d)
{}
//---------------------------------------------------------------------------------------------------------------------
@ -46,6 +52,7 @@ VPiece &VPiece::operator=(const VPiece &piece)
{
return *this;
}
VAbstractPiece::operator=(piece);
d = piece.d;
return *this;
}
@ -130,3 +137,113 @@ void VPiece::SetNodes(const QVector<VPieceNode> &nodes)
{
d->nodes = nodes;
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VPiece::MainPathPoints(const VContainer *data) const
{
QVector<QPointF> points;
for (int i = 0; i < CountNode(); ++i)
{
switch (at(i).GetTypeTool())
{
case (Tool::NodePoint):
{
const QSharedPointer<VPointF> point = data->GeometricObject<VPointF>(at(i).GetId());
points.append(*point);
}
break;
case (Tool::NodeArc):
case (Tool::NodeSpline):
case (Tool::NodeSplinePath):
{
const QSharedPointer<VAbstractCurve> curve = data->GeometricObject<VAbstractCurve>(at(i).GetId());
const QPointF begin = StartSegment(data, i, at(i).GetReverse());
const QPointF end = EndSegment(data, i, at(i).GetReverse());
points << curve->GetSegmentPoints(begin, end, at(i).GetReverse());
}
break;
default:
qDebug()<<"Get wrong tool type. Ignore."<< static_cast<char>(at(i).GetTypeTool());
break;
}
}
points = CheckLoops(CorrectEquidistantPoints(points));//A path can contains loops
return points;
}
//---------------------------------------------------------------------------------------------------------------------
QPointF VPiece::StartSegment(const VContainer *data, const int &i, bool reverse) const
{
if (i < 0 && i > CountNode()-1)
{
return QPointF();
}
const QSharedPointer<VAbstractCurve> curve = data->GeometricObject<VAbstractCurve>(at(i).GetId());
QVector<QPointF> points = curve->GetPoints();
if (reverse)
{
points = VGObject::GetReversePoints(points);
}
QPointF begin = points.first();
if (CountNode() > 1)
{
if (i == 0)
{
if (at(CountNode()-1).GetTypeTool() == Tool::NodePoint)
{
begin = *data->GeometricObject<VPointF>(at(CountNode()-1).GetId());
}
}
else
{
if (at(i-1).GetTypeTool() == Tool::NodePoint)
{
begin = *data->GeometricObject<VPointF>(at(i-1).GetId());
}
}
}
return begin;
}
//---------------------------------------------------------------------------------------------------------------------
QPointF VPiece::EndSegment(const VContainer *data, const int &i, bool reverse) const
{
if (i < 0 && i > CountNode()-1)
{
return QPointF();
}
const QSharedPointer<VAbstractCurve> curve = data->GeometricObject<VAbstractCurve>(at(i).GetId());
QVector<QPointF> points = curve->GetPoints();
if (reverse)
{
points = VGObject::GetReversePoints(points);
}
QPointF end = points.last();
if (CountNode() > 2)
{
if (i == CountNode() - 1)
{
if (at(0).GetTypeTool() == Tool::NodePoint)
{
end = *data->GeometricObject<VPointF>(at(0).GetId());
}
}
else
{
if (at(i+1).GetTypeTool() == Tool::NodePoint)
{
end = *data->GeometricObject<VPointF>(at(i+1).GetId());
}
}
}
return end;
}

13
src/libs/vpatterndb/vpiece.h
View File

@ -32,10 +32,15 @@
#include <QtGlobal>
#include <QSharedDataPointer>
#include "../vlayout/vabstractpiece.h"
class VPieceData;
class VPieceNode;
class QPointF;
class VContainer;
template <class T> class QVector;
class VPiece
class VPiece : public VAbstractPiece
{
public:
VPiece();
@ -53,8 +58,14 @@ public:
QVector<VPieceNode> GetNodes() const;
void SetNodes(const QVector<VPieceNode> &nodes);
QVector<QPointF> MainPathPoints(const VContainer *data) const;
private:
QSharedDataPointer<VPieceData> d;
QPointF StartSegment(const VContainer *data, const int &i, bool reverse) const;
QPointF EndSegment(const VContainer *data, const int &i, bool reverse) const;
};
Q_DECLARE_TYPEINFO(VPiece, Q_MOVABLE_TYPE);