palo/valentina
1
0
Fork 0
mirror of https://gitlab.com/smart-pattern/valentina.git synced 2024-07-01 00:28:12 +02:00
Code Issues Projects Releases Wiki Activity

Merged develop into feature

Browse source 
--HG--
branch : feature
This commit is contained in:
Bojan Kverh 2016-08-21 00:01:35 +02:00
parent 1cfa97497c 3dab49c23e
commit 19c69c691a
17 changed files with 642 additions and 280 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
ChangeLog.txt
View file

@ -36,6 +36,7 @@
- [#496] Selector for selecting which pieces to print.
- [#520] Improve Union tool. An option to select about original pieces.
- [#262] Automatic Update notification.
- [#424] Improve Formula Wizard dialog.
# Version 0.4.5
- [#435] Valentina doesn't change the cursor.
@ -56,6 +57,8 @@
- [#537] Valentina crashes when use undo command.
- [#544] Error: Color Lines are black until touched.
- [#543] Detail loses details.
- [#548] Bug Detail tool. Case when seam allowance is wrong.
- Called the main app in console mode doesn't show opening file error in some cases.
# Version 0.4.4 April 12, 2016
- Updated measurement templates with all measurements. Added new template Aldrich/Women measurements.

10
src/app/valentina/mainwindow.cpp
View file

@ -3855,9 +3855,15 @@ bool MainWindow::LoadPattern(const QString &fileName, const QString& customMeasu
ZoomFirstShow();
ActionDraw(true);
qApp->setOpeningPattern();// End opening file
return true;
}
else
{
qApp->setOpeningPattern();// End opening file
return false;
}
qApp->setOpeningPattern();// End opening file
return true;
}
//---------------------------------------------------------------------------------------------------------------------

422
src/libs/ifc/xml/vpatternconverter.cpp
View file

@ -64,6 +64,58 @@ const QString VPatternConverter::CurrentSchema = QStringLiteral("://schema/pa
//VPatternConverter::PatternMinVer; // <== DON'T FORGET TO UPDATE TOO!!!!
//VPatternConverter::PatternMaxVer; // <== DON'T FORGET TO UPDATE TOO!!!!
// The list of all string we use for conversion
// Better to use global variables because repeating QStringLiteral blows up code size
const QString strUnit = QStringLiteral("unit");
const QString strVersion = QStringLiteral("version");
const QString strName = QStringLiteral("name");
const QString strBase = QStringLiteral("base");
const QString strFormula = QStringLiteral("formula");
const QString strId = QStringLiteral("id");
const QString strKGrowth = QStringLiteral("kgrowth");
const QString strKSize = QStringLiteral("ksize");
const QString strPoint = QStringLiteral("point");
const QString strLength = QStringLiteral("length");
const QString strAngle = QStringLiteral("angle");
const QString strC1Radius = QStringLiteral("c1Radius");
const QString strC2Radius = QStringLiteral("c2Radius");
const QString strCRadius = QStringLiteral("cRadius");
const QString strArc = QStringLiteral("arc");
const QString strAngle1 = QStringLiteral("angle1");
const QString strAngle2 = QStringLiteral("angle2");
const QString strRadius = QStringLiteral("radius");
const QString strPathPoint = QStringLiteral("pathPoint");
const QString strKAsm1 = QStringLiteral("kAsm1");
const QString strKAsm2 = QStringLiteral("kAsm2");
const QString strPath = QStringLiteral("path");
const QString strType = QStringLiteral("type");
const QString strCutArc = QStringLiteral("cutArc");
const QString strSpline = QStringLiteral("spline");
const QString strSplinePath = QStringLiteral("splinePath");
const QString strCutSpline = QStringLiteral("cutSpline");
const QString strCutSplinePath = QStringLiteral("cutSplinePath");
const QString strColor = QStringLiteral("color");
const QString strMeasurements = QStringLiteral("measurements");
const QString strIncrement = QStringLiteral("increment");
const QString strIncrements = QStringLiteral("increments");
const QString strModeling = QStringLiteral("modeling");
const QString strTools = QStringLiteral("tools");
const QString strIdTool = QStringLiteral("idTool");
const QString strIdObject = QStringLiteral("idObject");
const QString strChildren = QStringLiteral("children");
const QString strChild = QStringLiteral("child");
const QString strPointOfIntersectionCurves = QStringLiteral("pointOfIntersectionCurves");
const QString strCurveIntersectAxis = QStringLiteral("curveIntersectAxis");
const QString strCurve = QStringLiteral("curve");
const QString strCurve1 = QStringLiteral("curve1");
const QString strCurve2 = QStringLiteral("curve2");
const QString strModelingPath = QStringLiteral("modelingPath");
const QString strModelingSpline = QStringLiteral("modelingSpline");
const QString strPointFromArcAndTangent = QStringLiteral("pointFromArcAndTangent");
const QString strPointOfIntersectionArcs = QStringLiteral("pointOfIntersectionArcs");
const QString strFirstArc = QStringLiteral("firstArc");
const QString strSecondArc = QStringLiteral("secondArc");
//---------------------------------------------------------------------------------------------------------------------
VPatternConverter::VPatternConverter(const QString &fileName)
:VAbstractConverter(fileName)
@ -316,6 +368,9 @@ void VPatternConverter::ToV0_2_7()
//---------------------------------------------------------------------------------------------------------------------
void VPatternConverter::ToV0_3_0()
{
//Cutting path do not create anymore subpaths
FixCutPoint();
FixCutPoint();
SetVersion(QStringLiteral("0.3.0"));
Save();
}
@ -345,12 +400,12 @@ void VPatternConverter::ToV0_3_3()
//---------------------------------------------------------------------------------------------------------------------
void VPatternConverter::TagUnitToV0_2_0()
{
QDomElement unit = createElement("unit");
QDomElement unit = createElement(strUnit);
QDomText newNodeText = createTextNode(MUnitV0_1_4());
unit.appendChild(newNodeText);
QDomElement patternElement = documentElement();
patternElement.insertAfter(unit, patternElement.firstChildElement("version"));
patternElement.insertAfter(unit, patternElement.firstChildElement(strVersion));
}
//---------------------------------------------------------------------------------------------------------------------
@ -385,16 +440,16 @@ QSet<QString> VPatternConverter::FixIncrementsToV0_2_0()
QDomElement domElement = domNode.toElement();
if (domElement.isNull() == false)
{
if (domElement.tagName() == "increment")
if (domElement.tagName() == strIncrement)
{
try
{
const QString name = GetParametrString(domElement, "name");
const QString name = GetParametrString(domElement, strName);
names.insert(name);
domElement.setAttribute("name", "#"+name);
domElement.setAttribute(strName, QLatin1String("#")+name);
const QString base = GetParametrString(domElement, "base");
domElement.setAttribute("formula", base);
const QString base = GetParametrString(domElement, strBase);
domElement.setAttribute(strFormula, base);
}
catch (VExceptionEmptyParameter &e)
{
@ -402,10 +457,10 @@ QSet<QString> VPatternConverter::FixIncrementsToV0_2_0()
excep.AddMoreInformation(e.ErrorMessage());
throw excep;
}
domElement.removeAttribute("id");
domElement.removeAttribute("kgrowth");
domElement.removeAttribute("ksize");
domElement.removeAttribute("base");
domElement.removeAttribute(strId);
domElement.removeAttribute(strKGrowth);
domElement.removeAttribute(strKSize);
domElement.removeAttribute(strBase);
}
}
}
@ -418,15 +473,15 @@ QSet<QString> VPatternConverter::FixIncrementsToV0_2_0()
void VPatternConverter::FixPointExpressionsToV0_2_0(const QSet<QString> &names)
{
QString formula;
const QDomNodeList list = elementsByTagName("point");
const QDomNodeList list = elementsByTagName(strPoint);
for (int i=0; i < list.size(); ++i)
{
QDomElement dom = list.at(i).toElement();
try
{
formula = GetParametrString(dom, "length");
dom.setAttribute("length", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strLength);
dom.setAttribute(strLength, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -435,8 +490,8 @@ void VPatternConverter::FixPointExpressionsToV0_2_0(const QSet<QString> &names)
try
{
formula = GetParametrString(dom, "angle");
dom.setAttribute("angle", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strAngle);
dom.setAttribute(strAngle, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -444,8 +499,8 @@ void VPatternConverter::FixPointExpressionsToV0_2_0(const QSet<QString> &names)
}
try
{
formula = GetParametrString(dom, "c1Radius");
dom.setAttribute("c1Radius", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strC1Radius);
dom.setAttribute(strC1Radius, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -454,8 +509,8 @@ void VPatternConverter::FixPointExpressionsToV0_2_0(const QSet<QString> &names)
try
{
formula = GetParametrString(dom, "c2Radius");
dom.setAttribute("c2Radius", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strC2Radius);
dom.setAttribute(strC2Radius, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -464,8 +519,8 @@ void VPatternConverter::FixPointExpressionsToV0_2_0(const QSet<QString> &names)
try
{
formula = GetParametrString(dom, "cRadius");
dom.setAttribute("cRadius", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strCRadius);
dom.setAttribute(strCRadius, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -478,15 +533,15 @@ void VPatternConverter::FixPointExpressionsToV0_2_0(const QSet<QString> &names)
void VPatternConverter::FixArcExpressionsToV0_2_0(const QSet<QString> &names)
{
QString formula;
const QDomNodeList list = elementsByTagName("arc");
const QDomNodeList list = elementsByTagName(strArc);
for (int i=0; i < list.size(); ++i)
{
QDomElement dom = list.at(i).toElement();
try
{
formula = GetParametrString(dom, "angle1");
dom.setAttribute("angle1", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strAngle1);
dom.setAttribute(strAngle1, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -495,8 +550,8 @@ void VPatternConverter::FixArcExpressionsToV0_2_0(const QSet<QString> &names)
try
{
formula = GetParametrString(dom, "angle2");
dom.setAttribute("angle2", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strAngle2);
dom.setAttribute(strAngle2, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -505,8 +560,8 @@ void VPatternConverter::FixArcExpressionsToV0_2_0(const QSet<QString> &names)
try
{
formula = GetParametrString(dom, "radius");
dom.setAttribute("radius", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strRadius);
dom.setAttribute(strRadius, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -515,8 +570,8 @@ void VPatternConverter::FixArcExpressionsToV0_2_0(const QSet<QString> &names)
try
{
formula = GetParametrString(dom, "length");
dom.setAttribute("length", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strLength);
dom.setAttribute(strLength, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -529,15 +584,15 @@ void VPatternConverter::FixArcExpressionsToV0_2_0(const QSet<QString> &names)
void VPatternConverter::FixPathPointExpressionsToV0_2_0(const QSet<QString> &names)
{
QString formula;
const QDomNodeList list = elementsByTagName("pathPoint");
const QDomNodeList list = elementsByTagName(strPathPoint);
for (int i=0; i < list.size(); ++i)
{
QDomElement dom = list.at(i).toElement();
try
{
formula = GetParametrString(dom, "kAsm1");
dom.setAttribute("kAsm1", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strKAsm1);
dom.setAttribute(strKAsm1, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -546,8 +601,8 @@ void VPatternConverter::FixPathPointExpressionsToV0_2_0(const QSet<QString> &nam
try
{
formula = GetParametrString(dom, "kAsm2");
dom.setAttribute("kAsm2", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strKAsm2);
dom.setAttribute(strKAsm2, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -556,8 +611,8 @@ void VPatternConverter::FixPathPointExpressionsToV0_2_0(const QSet<QString> &nam
try
{
formula = GetParametrString(dom, "angle");
dom.setAttribute("angle", FixIncrementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strAngle);
dom.setAttribute(strAngle, FixIncrementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -570,15 +625,15 @@ void VPatternConverter::FixPathPointExpressionsToV0_2_0(const QSet<QString> &nam
void VPatternConverter::ConvertPointExpressionsToV0_2_0(const QMap<QString, QString> &names)
{
QString formula;
const QDomNodeList list = elementsByTagName("point");
const QDomNodeList list = elementsByTagName(strPoint);
for (int i=0; i < list.size(); ++i)
{
QDomElement dom = list.at(i).toElement();
try
{
formula = GetParametrString(dom, "length");
dom.setAttribute("length", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strLength);
dom.setAttribute(strLength, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -587,8 +642,8 @@ void VPatternConverter::ConvertPointExpressionsToV0_2_0(const QMap<QString, QStr
try
{
formula = GetParametrString(dom, "angle");
dom.setAttribute("angle", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strAngle);
dom.setAttribute(strAngle, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -596,8 +651,8 @@ void VPatternConverter::ConvertPointExpressionsToV0_2_0(const QMap<QString, QStr
}
try
{
formula = GetParametrString(dom, "c1Radius");
dom.setAttribute("c1Radius", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strC1Radius);
dom.setAttribute(strC1Radius, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -606,8 +661,8 @@ void VPatternConverter::ConvertPointExpressionsToV0_2_0(const QMap<QString, QStr
try
{
formula = GetParametrString(dom, "c2Radius");
dom.setAttribute("c2Radius", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strC2Radius);
dom.setAttribute(strC2Radius, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -616,8 +671,8 @@ void VPatternConverter::ConvertPointExpressionsToV0_2_0(const QMap<QString, QStr
try
{
formula = GetParametrString(dom, "cRadius");
dom.setAttribute("cRadius", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strCRadius);
dom.setAttribute(strCRadius, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -630,15 +685,15 @@ void VPatternConverter::ConvertPointExpressionsToV0_2_0(const QMap<QString, QStr
void VPatternConverter::ConvertArcExpressionsToV0_2_0(const QMap<QString, QString> &names)
{
QString formula;
const QDomNodeList list = elementsByTagName("arc");
const QDomNodeList list = elementsByTagName(strArc);
for (int i=0; i < list.size(); ++i)
{
QDomElement dom = list.at(i).toElement();
try
{
formula = GetParametrString(dom, "angle1");
dom.setAttribute("angle1", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strAngle1);
dom.setAttribute(strAngle1, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -647,8 +702,8 @@ void VPatternConverter::ConvertArcExpressionsToV0_2_0(const QMap<QString, QStrin
try
{
formula = GetParametrString(dom, "angle2");
dom.setAttribute("angle2", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strAngle2);
dom.setAttribute(strAngle2, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -657,8 +712,8 @@ void VPatternConverter::ConvertArcExpressionsToV0_2_0(const QMap<QString, QStrin
try
{
formula = GetParametrString(dom, "radius");
dom.setAttribute("radius", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strRadius);
dom.setAttribute(strRadius, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -667,8 +722,8 @@ void VPatternConverter::ConvertArcExpressionsToV0_2_0(const QMap<QString, QStrin
try
{
formula = GetParametrString(dom, "length");
dom.setAttribute("length", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strLength);
dom.setAttribute(strLength, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -681,15 +736,15 @@ void VPatternConverter::ConvertArcExpressionsToV0_2_0(const QMap<QString, QStrin
void VPatternConverter::ConvertPathPointExpressionsToV0_2_0(const QMap<QString, QString> &names)
{
QString formula;
const QDomNodeList list = elementsByTagName("pathPoint");
const QDomNodeList list = elementsByTagName(strPathPoint);
for (int i=0; i < list.size(); ++i)
{
QDomElement dom = list.at(i).toElement();
try
{
formula = GetParametrString(dom, "kAsm1");
dom.setAttribute("kAsm1", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strKAsm1);
dom.setAttribute(strKAsm1, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -698,8 +753,8 @@ void VPatternConverter::ConvertPathPointExpressionsToV0_2_0(const QMap<QString,
try
{
formula = GetParametrString(dom, "kAsm2");
dom.setAttribute("kAsm2", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strKAsm2);
dom.setAttribute(strKAsm2, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -708,8 +763,8 @@ void VPatternConverter::ConvertPathPointExpressionsToV0_2_0(const QMap<QString,
try
{
formula = GetParametrString(dom, "angle");
dom.setAttribute("angle", FixMeasurementInFormulaToV0_2_0(formula, names));
formula = GetParametrString(dom, strAngle);
dom.setAttribute(strAngle, FixMeasurementInFormulaToV0_2_0(formula, names));
}
catch (VExceptionEmptyParameter &e)
{
@ -782,11 +837,11 @@ QString VPatternConverter::FixIncrementInFormulaToV0_2_0(const QString &formula,
void VPatternConverter::TagMeasurementsToV0_2_0()
{
QDomElement ms = TagMeasurementsV0_1_4();
const QString path = GetParametrString(ms, "path");
const QString path = GetParametrString(ms, strPath);
ms.removeAttribute("unit");
ms.removeAttribute("type");
ms.removeAttribute("path");
ms.removeAttribute(strUnit);
ms.removeAttribute(strType);
ms.removeAttribute(strPath);
QDomText newNodeText = createTextNode(QFileInfo(fileName).absoluteDir().relativeFilePath(path));
ms.appendChild(newNodeText);
@ -806,18 +861,16 @@ void VPatternConverter::ConvertMeasurementsToV0_2_1()
//---------------------------------------------------------------------------------------------------------------------
void VPatternConverter::RemoveColorToolCutV0_3_1()
{
const QDomNodeList list = elementsByTagName("point");
const QDomNodeList list = elementsByTagName(strPoint);
for (int i=0; i < list.size(); ++i)
{
QDomElement element = list.at(i).toElement();
if (not element.isNull())
{
const QString type = element.attribute(QStringLiteral("type"));
if (type == QStringLiteral("cutArc") ||
type == QStringLiteral("cutSpline") ||
type == QStringLiteral("cutSplinePath"))
const QString type = element.attribute(strType);
if (type == strCutArc || type == strCutSpline || type == strCutSplinePath)
{
element.removeAttribute(QStringLiteral("color"));
element.removeAttribute(strColor);
}
}
}
@ -829,7 +882,7 @@ QString VPatternConverter::MUnitV0_1_4() const
const QDomElement element = TagMeasurementsV0_1_4();
try
{
return GetParametrString(element, "unit");
return GetParametrString(element, strUnit);
}
catch (VExceptionEmptyParameter &e)
{
@ -842,7 +895,7 @@ QString VPatternConverter::MUnitV0_1_4() const
//---------------------------------------------------------------------------------------------------------------------
QDomElement VPatternConverter::TagMeasurementsV0_1_4() const
{
const QDomNodeList list = elementsByTagName("measurements");
const QDomNodeList list = elementsByTagName(strMeasurements);
const QDomElement element = list.at(0).toElement();
if (not element.isElement())
{
@ -855,7 +908,7 @@ QDomElement VPatternConverter::TagMeasurementsV0_1_4() const
//---------------------------------------------------------------------------------------------------------------------
QDomElement VPatternConverter::TagIncrementsV0_1_4() const
{
const QDomNodeList list = elementsByTagName("increments");
const QDomNodeList list = elementsByTagName(strIncrements);
const QDomElement element = list.at(0).toElement();
if (not element.isElement())
{
@ -869,14 +922,14 @@ QDomElement VPatternConverter::TagIncrementsV0_1_4() const
QStringList VPatternConverter::ListPathPointExpressionsV0_1_4() const
{
QStringList expressions;
const QDomNodeList list = elementsByTagName("pathPoint");
const QDomNodeList list = elementsByTagName(strPathPoint);
for (int i=0; i < list.size(); ++i)
{
const QDomElement dom = list.at(i).toElement();
try
{
expressions.append(GetParametrString(dom, "kAsm1"));
expressions.append(GetParametrString(dom, strKAsm1));
}
catch (VExceptionEmptyParameter &e)
{
@ -885,7 +938,7 @@ QStringList VPatternConverter::ListPathPointExpressionsV0_1_4() const
try
{
expressions.append(GetParametrString(dom, "kAsm2"));
expressions.append(GetParametrString(dom, strKAsm2));
}
catch (VExceptionEmptyParameter &e)
{
@ -894,7 +947,7 @@ QStringList VPatternConverter::ListPathPointExpressionsV0_1_4() const
try
{
expressions.append(GetParametrString(dom, "angle"));
expressions.append(GetParametrString(dom, strAngle));
}
catch (VExceptionEmptyParameter &e)
{
@ -909,7 +962,7 @@ QStringList VPatternConverter::ListPathPointExpressionsV0_1_4() const
void VPatternConverter::FixToolUnionToV0_2_4()
{
QDomElement root = documentElement();
const QDomNodeList modelings = root.elementsByTagName(QStringLiteral("modeling"));
const QDomNodeList modelings = root.elementsByTagName(strModeling);
for (int i=0; i<modelings.size(); ++i)
{
ParseModelingToV0_2_4(modelings.at(i).toElement());
@ -922,17 +975,16 @@ void VPatternConverter::ParseModelingToV0_2_4(const QDomElement &modeling)
QDomElement node = modeling.firstChild().toElement();
while (not node.isNull())
{
if (node.tagName() == QLatin1String("tools"))
if (node.tagName() == strTools)
{
const quint32 toolId = node.attribute(QStringLiteral("id")).toUInt();
const quint32 toolId = node.attribute(strId).toUInt();
QVector<quint32> children;
QDomElement childNode = node.nextSibling().toElement();
const QString attrIdTool = QStringLiteral("idTool");
while (not childNode.isNull())
{
if (childNode.hasAttribute(attrIdTool) && childNode.attribute(attrIdTool).toUInt() == toolId)
if (childNode.hasAttribute(strIdTool) && childNode.attribute(strIdTool).toUInt() == toolId)
{
children.append(childNode.attribute(QStringLiteral("idObject")).toUInt());
children.append(childNode.attribute(strIdObject).toUInt());
}
else
{
@ -961,11 +1013,11 @@ void VPatternConverter::SaveChildrenToolUnionToV0_2_4(quint32 id, const QVector<
return;
}
QDomElement tagChildren = createElement(QString("children"));
QDomElement tagChildren = createElement(strChildren);
for (int i=0; i<children.size(); ++i)
{
QDomElement tagChild = createElement(QString("child"));
QDomElement tagChild = createElement(strChild);
tagChild.appendChild(createTextNode(QString().setNum(children.at(i))));
tagChildren.appendChild(tagChild);
}
@ -1160,3 +1212,193 @@ QMap<QString, QString> VPatternConverter::OldNamesToNewNames_InV0_2_1()
return names;
}
//---------------------------------------------------------------------------------------------------------------------
void VPatternConverter::FixCutPoint()
{
const QStringList types = QStringList() << strCutSplinePath
<< strCutSpline
<< strCutArc;
const QDomNodeList list = elementsByTagName(strPoint);
for (int i=0; i < list.size(); ++i)
{
QDomElement element = list.at(i).toElement();
if (not element.isNull())
{
const QString type = element.attribute(strType);
switch(types.indexOf(type))
{
case 0: //strCutSplinePath
{
const quint32 id = element.attribute(strId).toUInt();
quint32 curve = element.attribute(strSplinePath).toUInt();
FixSubPaths(i, id, curve);
break;
}
case 1: //strCutSpline
{
const quint32 id = element.attribute(strId).toUInt();
quint32 curve = element.attribute(strSpline).toUInt();
FixSubPaths(i, id, curve);
break;
}
case 2: //strCutArc
{
const quint32 id = element.attribute(strId).toUInt();
quint32 curve = element.attribute(strArc).toUInt();
FixSubPaths(i, id, curve);
break;
}
default:
break;
}
}
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPatternConverter::FixSubPaths(int i, quint32 id, quint32 baseCurve)
{
const QStringList pointTypes = QStringList() << strCutSplinePath
<< strCutSpline
<< strPointOfIntersectionCurves
<< strCurveIntersectAxis
<< strPointFromArcAndTangent
<< strPointOfIntersectionArcs;
const QDomNodeList listPoints = elementsByTagName(strPoint);
for (int j = i+1; j < listPoints.size(); ++j)
{
QDomElement element = listPoints.at(j).toElement();
if (not element.isNull())
{
const QString type = element.attribute(strType);
switch(pointTypes.indexOf(type))
{
case 0: //strCutSplinePath
{
const quint32 spl = element.attribute(strSplinePath).toUInt();
if (spl == id+1 || spl == id+2)
{
element.setAttribute(strSplinePath, baseCurve);
}
break;
}
case 1: //strCutSpline
{
const quint32 spl = element.attribute(strSpline).toUInt();
if (spl == id+1 || spl == id+2)
{
element.setAttribute(strSpline, baseCurve);
}
break;
}
case 2: //strPointOfIntersectionCurves
{
quint32 spl = element.attribute(strCurve1).toUInt();
if (spl == id+1 || spl == id+2)
{
element.setAttribute(strCurve1, baseCurve);
}
spl = element.attribute(strCurve2).toUInt();
if (spl == id+1 || spl == id+2)
{
element.setAttribute(strCurve2, baseCurve);
}
break;
}
case 3: //strCurveIntersectAxis
{
const quint32 spl = element.attribute(strCurve).toUInt();
if (spl == id+1 || spl == id+2)
{
element.setAttribute(strCurve, baseCurve);
}
break;
}
case 4: //strPointFromArcAndTangent
{
const quint32 spl = element.attribute(strArc).toUInt();
if (spl == id+1 || spl == id+2)
{
element.setAttribute(strArc, baseCurve);
}
break;
}
case 5: //strPointOfIntersectionArcs
{
quint32 arc = element.attribute(strFirstArc).toUInt();
if (arc == id+1 || arc == id+2)
{
element.setAttribute(strFirstArc, baseCurve);
}
arc = element.attribute(strSecondArc).toUInt();
if (arc == id+1 || arc == id+2)
{
element.setAttribute(strSecondArc, baseCurve);
}
break;
}
default:
break;
}
}
}
const QStringList splTypes = QStringList() << strModelingPath
<< strModelingSpline;
const QDomNodeList listSplines = elementsByTagName(strSpline);
for (int j = 0; j < listSplines.size(); ++j)
{
QDomElement element = listSplines.at(j).toElement();
if (not element.isNull())
{
const QString type = element.attribute(strType);
switch(splTypes.indexOf(type))
{
case 0: //strModelingPath
{
const quint32 spl = element.attribute(strIdObject).toUInt();
if (spl == id+1 || spl == id+2)
{
element.setAttribute(strIdObject, baseCurve);
}
break;
}
case 1: //strModelingSpline
{
const quint32 spl = element.attribute(strIdObject).toUInt();
if (spl == id+1 || spl == id+2)
{
element.setAttribute(strIdObject, baseCurve);
}
break;
}
default:
break;
}
}
}
const QDomNodeList listArcs = elementsByTagName(strArc);
for (int j = 0; j < listArcs.size(); ++j)
{
QDomElement element = listArcs.at(j).toElement();
if (not element.isNull())
{
const QString type = element.attribute(strType);
if (type == strModeling)
{
const quint32 arc = element.attribute(strIdObject).toUInt();
if (arc == id+1 || arc == id+2)
{
element.setAttribute(strIdObject, baseCurve);
}
}
}
}
}

3
src/libs/ifc/xml/vpatternconverter.h
View file

@ -118,6 +118,9 @@ private:
static QMap<QString, QString> OldNamesToNewNames_InV0_2_0();
static QMap<QString, QString> OldNamesToNewNames_InV0_2_1();
void FixCutPoint();
void FixSubPaths(int i, quint32 id, quint32 baseCurve);
};
//---------------------------------------------------------------------------------------------------------------------

4
src/libs/vgeometry/varc.cpp
View file

@ -241,7 +241,11 @@ QVector<QPointF> VArc::GetPoints() const
QVector<QPointF> splPoints = spl.GetPoints();
if (not splPoints.isEmpty() && i != sectionAngle.size() - 1)
{
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
splPoints.remove(splPoints.size() - 1);
#else
splPoints.removeLast();
#endif
}
points << splPoints;

4
src/libs/vgeometry/vellipticalarc.cpp
View file

@ -366,7 +366,11 @@ QVector<QPointF> VEllipticalArc::GetPoints() const
if (not splPoints.isEmpty() && i != sectionAngle.size() - 1)
{
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
splPoints.remove(splPoints.size() - 1);
#else
splPoints.removeLast();
#endif
}
points << splPoints;
currentAngle += sectionAngle.at(i);

12
src/libs/vlayout/vabstractdetail.cpp
View file

@ -269,7 +269,6 @@ QVector<QPointF> VAbstractDetail::RemoveDublicates(const QVector<QPointF> &point
*/
QVector<QPointF> VAbstractDetail::CorrectEquidistantPoints(const QVector<QPointF> &points)
{
QVector<QPointF> correctPoints;
if (points.size()<4)//Better don't check if only three points. We can destroy equidistant.
{
qDebug()<<"Only three points.";
@ -277,20 +276,17 @@ QVector<QPointF> VAbstractDetail::CorrectEquidistantPoints(const QVector<QPointF
}
//Clear equivalent points
correctPoints = RemoveDublicates(points);
QVector<QPointF> correctPoints = RemoveDublicates(points);
if (correctPoints.size()<3)
{
return correctPoints;
}
//Remove point on line
QPointF point;
for (qint32 i = 1; i <correctPoints.size()-1; ++i)
{
QLineF l1(correctPoints.at(i-1), correctPoints.at(i));
QLineF l2(correctPoints.at(i), correctPoints.at(i+1));
QLineF::IntersectType intersect = l1.intersect(l2, &point);
if (intersect == QLineF::NoIntersection)
{// 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);
}

2
src/libs/vlayout/vabstractdetail.h
View file

@ -70,10 +70,10 @@ public:
static QVector<QPointF> Equidistant(const QVector<QPointF> &points, const EquidistantType &eqv, qreal width);
static qreal SumTrapezoids(const QVector<QPointF> &points);
static QVector<QPointF> CheckLoops(const QVector<QPointF> &points);
static QVector<QPointF> CorrectEquidistantPoints(const QVector<QPointF> &points);
protected:
static QVector<QPointF> RemoveDublicates(const QVector<QPointF> &points);
static QVector<QPointF> CorrectEquidistantPoints(const QVector<QPointF> &points);
private:
QSharedDataPointer<VAbstractDetailData> d;

8
src/libs/vpatterndb/vtranslatevars.cpp
View file

@ -403,7 +403,7 @@ void VTranslateVars::InitFunctions()
functions.insert(cosh_F, translate("VTranslateVars", "cosh", "hyperbolic cosine"));
functions.insert(tanh_F, translate("VTranslateVars", "tanh", "hyperbolic tangens function"));
functions.insert(asinh_F, translate("VTranslateVars", "asinh", "hyperbolic arcus sine function"));
functions.insert(acosh_F, translate("VTranslateVars", "acosh", "hyperbolic arcus tangens function"));
functions.insert(acosh_F, translate("VTranslateVars", "acosh", "hyperbolic arcus cosine function"));
functions.insert(atanh_F, translate("VTranslateVars", "atanh", "hyperbolic arcur tangens function"));
functions.insert(log2_F, translate("VTranslateVars", "log2", "logarithm to the base 2"));
functions.insert(log10_F, translate("VTranslateVars", "log10", "logarithm to the base 10"));
@ -946,3 +946,9 @@ void VTranslateVars::Retranslate()
InitFunctions();
InitPostfixOperators();
}
//---------------------------------------------------------------------------------------------------------------------
QMap<QString, QmuTranslation> VTranslateVars::GetFunctions() const
{
return functions;
}

1
src/libs/vpatterndb/vtranslatevars.h
View file

@ -61,6 +61,7 @@ public:
QString FormulaToUser(const QString &formula, bool osSeparator) const;
virtual void Retranslate() Q_DECL_OVERRIDE;
QMap<QString, qmu::QmuTranslation> GetFunctions() const;
private:
Q_DISABLE_COPY(VTranslateVars)

44
src/libs/vtools/dialogs/support/dialogeditwrongformula.cpp
View file

@ -217,6 +217,11 @@ void DialogEditWrongFormula::ValChanged(int row)
degreeSymbol, tr("Curve angle"));
return;
}
if (ui->radioButtonFunctions->isChecked())
{
ui->labelDescription->setText(item->toolTip());
return;
}
}
//---------------------------------------------------------------------------------------------------------------------
@ -309,6 +314,16 @@ void DialogEditWrongFormula::Increments()
ShowVariable(data->DataIncrements());
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Functions show in list functions
*/
void DialogEditWrongFormula::Functions()
{
ui->checkBoxHideEmpty->setEnabled(false);
ShowFunctions();
}
//---------------------------------------------------------------------------------------------------------------------
void DialogEditWrongFormula::CheckState()
{
@ -384,6 +399,7 @@ void DialogEditWrongFormula::InitVariables()
connect(ui->checkBoxHideEmpty, &QCheckBox::stateChanged, this, &DialogEditWrongFormula::Measurements);
connect(ui->radioButtonRadiusesArcs, &QRadioButton::clicked, this, &DialogEditWrongFormula::RadiusArcs);
connect(ui->radioButtonAnglesCurves, &QRadioButton::clicked, this, &DialogEditWrongFormula::AnglesCurves);
connect(ui->radioButtonFunctions, &QRadioButton::clicked, this, &DialogEditWrongFormula::Functions);
}
//---------------------------------------------------------------------------------------------------------------------
@ -477,3 +493,31 @@ void DialogEditWrongFormula::ShowMeasurements(const QMap<QString, QSharedPointer
ui->tableWidget->selectRow(0);
ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief ShowFunctions show functions in list
*/
void DialogEditWrongFormula::ShowFunctions()
{
ui->tableWidget->blockSignals(true);
ui->tableWidget->clearContents();
ui->tableWidget->setRowCount(0);
ui->tableWidget->setColumnHidden(ColumnFullName, true);
ui->labelDescription->setText("");
QMap<QString, qmu::QmuTranslation>::const_iterator i = qApp->TrVars()->GetFunctions().constBegin();
while (i != qApp->TrVars()->GetFunctions().constEnd())
{
ui->tableWidget->setRowCount(ui->tableWidget->rowCount() + 1);
QTableWidgetItem *item = new QTableWidgetItem(i.value().translate());
item->setFont(QFont("Times", 12, QFont::Bold));
ui->tableWidget->setItem(ui->tableWidget->rowCount()-1, ColumnName, item);
item->setToolTip(i.value().getMdisambiguation());
++i;
}
ui->tableWidget->blockSignals(false);
ui->tableWidget->selectRow(0);
ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
}

2
src/libs/vtools/dialogs/support/dialogeditwrongformula.h
View file

@ -90,6 +90,7 @@ public slots:
void LengthCurves();
void AngleLines();
void Increments();
void Functions();
protected:
virtual void CheckState() Q_DECL_OVERRIDE;
virtual void closeEvent(QCloseEvent *event) Q_DECL_OVERRIDE;
@ -113,6 +114,7 @@ private:
template <class key, class val>
void ShowVariable(const QMap<key, val> &var);
void ShowMeasurements(const QMap<QString, QSharedPointer<VMeasurement> > &var);
void ShowFunctions();
void SetDescription(const QString &name, qreal value, const QString &unit, const QString &description);
};

13
src/libs/vtools/dialogs/support/dialogeditwrongformula.ui
View file

@ -329,6 +329,19 @@
</property>
</widget>
</item>
<item>
<widget class="QRadioButton" name="radioButtonFunctions">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Functions</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>

78
src/libs/vtools/tools/vtooluniondetails.cpp
View file

@ -676,45 +676,61 @@ VToolUnionDetails* VToolUnionDetails::Create(const quint32 _id, const VDetail &d
QVector<quint32> children = AllChildren(doc, id);
if (not children.isEmpty())
{
qint32 i = 0;
do
// This check need for backward compatibility
// Remove check and "else" part if min version is 0.3.2
Q_STATIC_ASSERT_X(VPatternConverter::PatternMinVer < CONVERTER_VERSION_CHECK(0, 3, 2),
"Time to refactor the code.");
if (children.size() == countNodeD1 + countNodeD2-1)
{
// This check need for backward compatibility
// Remove it if min version is 0.3.2
// Instead:
// UpdatePoints(data, d1.RemoveEdge(indexD1), i, children);
Q_STATIC_ASSERT_X(VPatternConverter::PatternMinVer < CONVERTER_VERSION_CHECK(0, 3, 2),
"Time to refactor the code.");
if (children.size() != countNodeD2)
qint32 i = 0;
do
{
UpdatePoints(data, d1.RemoveEdge(indexD1), i, children);
}
++i;
if (i > d1.indexOfNode(det1p1.getId()) && pointsD2 < countNodeD2-1)
{
VDetail d2REdge = d2.RemoveEdge(indexD2);
qint32 j = 0;
FindIndexJ(pointsD2, d2, indexD2, j);
do
++i;
if (i > d1.indexOfNode(det1p1.getId()) && pointsD2 < countNodeD2-1)
{
if (j >= countNodeD2)
VDetail d2REdge = d2.RemoveEdge(indexD2);
qint32 j = 0;
FindIndexJ(pointsD2, d2, indexD2, j);
do
{
j=0;
}
UpdatePoints(data, d2REdge, j, children, dx, dy, det1p1.getId(), angle);
++pointsD2;
++j;
} while (pointsD2 < countNodeD2-1);
// This check need for backward compatibility
// Remove it if min version is 0.3.2
Q_STATIC_ASSERT_X(VPatternConverter::PatternMinVer < CONVERTER_VERSION_CHECK(0, 3, 2),
"Time to refactor the code.");
if (children.size() == countNodeD2)
if (j >= countNodeD2)
{
j=0;
}
UpdatePoints(data, d2REdge, j, children, dx, dy, det1p1.getId(), angle);
++pointsD2;
++j;
} while (pointsD2 < countNodeD2-1);
}
} while (i<countNodeD1);
}
else // remove if min version is 0.3.2
{
qint32 i = 0;
do
{
++i;
if (i > d1.indexOfNode(det1p1.getId()))
{
const int childrenCount = children.size();
VDetail d2REdge = d2.RemoveEdge(indexD2);
qint32 j = 0;
FindIndexJ(pointsD2, d2, indexD2, j);
do
{
if (j >= countNodeD2)
{
j=0;
}
UpdatePoints(data, d2REdge, j, children, dx, dy, det1p1.getId(), angle);
++pointsD2;
++j;
} while (pointsD2 < childrenCount);
break;
}
}
} while (i<countNodeD1);
} while (i<countNodeD1);
}
}
}
return unionDetails;

266
src/test/ValentinaTest/tst_vabstractdetail.cpp
View file

@ -40,6 +40,25 @@ TST_VAbstractDetail::TST_VAbstractDetail(QObject *parent)
{
}
//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractDetail::EquidistantRemoveLoop_data()
{
QTest::addColumn<QVector<QPointF>>("points");
QTest::addColumn<int>("eqv");
QTest::addColumn<qreal>("width");
QTest::addColumn<QVector<QPointF>>("ekvOrig");
QTest::newRow("Case1") << InputPointsCase1()
<< static_cast<int>(EquidistantType::CloseEquidistant)
<< 75.5906 // seam allowance width
<< OutputPointsCase1();
QTest::newRow("Case2") << InputPointsCase2()
<< static_cast<int>(EquidistantType::CloseEquidistant)
<< 37.7953 // seam allowance width
<< OutputPointsCase2();
}
//---------------------------------------------------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
void TST_VAbstractDetail::EquidistantRemoveLoop() const
@ -48,8 +67,15 @@ void TST_VAbstractDetail::EquidistantRemoveLoop() const
// See issue #298. Segmented Curve isn't selected in Seam Allowance tool.
// https://bitbucket.org/dismine/valentina/issue/298/segmented-curve-isnt-selected-in-seam
// Code should clean loops in path.
Case1();
Case2();
QFETCH(QVector<QPointF>, points);
QFETCH(int, eqv);
QFETCH(qreal, width);
QFETCH(QVector<QPointF>, ekvOrig);
const QVector<QPointF> ekv = VAbstractDetail::Equidistant(points, static_cast<EquidistantType>(eqv), width);
// Begin comparison
Comparison(ekv, ekvOrig);
}
//---------------------------------------------------------------------------------------------------------------------
@ -77,7 +103,11 @@ void TST_VAbstractDetail::PathRemoveLoop_data() const
path << QPointF(10, 10);
QTest::newRow("Correct closed a path (four unique points)") << path << path;
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
path.remove(path.size() - 1);
#else
path.removeLast();
#endif
QTest::newRow("Correct unclosed a path (four unique points)") << path << path;
path.clear();
@ -90,7 +120,11 @@ void TST_VAbstractDetail::PathRemoveLoop_data() const
path << QPointF(0, 10);
QTest::newRow("Correct closed a path (six unique points)") << path << path;
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
path.remove(path.size() - 1);
#else
path.removeLast();
#endif
QTest::newRow("Correct unclosed a path (six unique points)") << path << path;
path.clear();
@ -107,8 +141,13 @@ void TST_VAbstractDetail::PathRemoveLoop_data() const
res << QPointF(20, 10);
QTest::newRow("One loop, closed a path (four unique points)") << path << res;
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
path.remove(path.size() - 1);
res.remove(res.size() - 1);
#else
path.removeLast();
res.removeLast();
#endif
QTest::newRow("One loop, unclosed a path (four unique points)") << path << res;
path.clear();
@ -127,8 +166,13 @@ void TST_VAbstractDetail::PathRemoveLoop_data() const
res << QPointF(20, 10);
QTest::newRow("Two loops, closed a path (six unique points)") << path << res;
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
path.remove(path.size() - 1);
res.remove(res.size() - 1);
#else
path.removeLast();
res.removeLast();
#endif
QTest::newRow("Two loops, unclosed a path (six unique points)") << path << res;
path.clear();
@ -147,8 +191,13 @@ void TST_VAbstractDetail::PathRemoveLoop_data() const
res << QPointF(20, 10);
QTest::newRow("One loop, the first loop, closed a path (six unique points)") << path << res;
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
path.remove(path.size() - 1);
res.remove(res.size() - 1);
#else
path.removeLast();
res.removeLast();
#endif
QTest::newRow("One loop, the first loop, unclosed a path (six unique points)") << path << res;
path.clear();
@ -169,8 +218,13 @@ void TST_VAbstractDetail::PathRemoveLoop_data() const
res << QPointF(20, 10);
QTest::newRow("One loop, the second loop, closed a path (six unique points)") << path << res;
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
path.remove(path.size() - 1);
res.remove(res.size() - 1);
#else
path.removeLast();
res.removeLast();
#endif
QTest::newRow("One loop, the second loop, unclosed a path (six unique points)") << path << res;
path.clear();
@ -182,7 +236,11 @@ void TST_VAbstractDetail::PathRemoveLoop_data() const
path << QPointF(20, 10);
QTest::newRow("Correct closed a path, point on line (four unique points)") << path << path;
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
path.remove(path.size() - 1);
#else
path.removeLast();
#endif
QTest::newRow("Corect unclosed a path, point on line (four unique points)") << path << path;
path.clear();
@ -197,7 +255,11 @@ void TST_VAbstractDetail::PathRemoveLoop_data() const
path << QPointF(20, 10);
QTest::newRow("Correct closed a path, point on line (six unique points)") << path << path;
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
path.remove(path.size() - 1);
#else
path.removeLast();
#endif
QTest::newRow("Corect unclosed a path, point on line (six unique points)") << path << path;
path.clear();
@ -410,11 +472,15 @@ void TST_VAbstractDetail::BrokenDetailEquidistant() const
// We will test only one detail. The second require too accurate data that we cannot get from debuger.
// The test check an open equdistant of correct detail.
QVector<QPointF> points;// Input points.
points.append(QPointF(1062.36226525, 134.022845566));
points.append(QPointF(1375.53777429, 66.4182791729));
points.append(QPointF(1422.22769398, 510.762708661));
points.append(QPointF(1467.89850709, 945.408377953));
points.append(QPointF(1127.74102677, 510.762708661));
points.append(QPointF(787.5835464566929, 1701.3138897637796));
points.append(QPointF(938.7646488188976, 1701.3138897637796));
points.append(QPointF(910.0209091217698, 1792.3369853889722));
points.append(QPointF(878.5244039283091, 1905.2261617043234));
points.append(QPointF(863.9159293830619, 1968.2534932384856));
points.append(QPointF(852.8936778444679, 1919.6965437838999));
points.append(QPointF(819.0677656132684, 1798.6758641921479));
points.append(QPointF(787.5835464566929, 1701.3138897637796));
points.append(QPointF(797.0323653543306, 2608.4005039370077));
const EquidistantType eqv = EquidistantType::OpenEquidistant; // Open path
const qreal width = 37.795275590551185; // seam allowance width
@ -422,43 +488,55 @@ void TST_VAbstractDetail::BrokenDetailEquidistant() const
const QVector<QPointF> ekv = VAbstractDetail::Equidistant(points, eqv, width);// Take result
QVector<QPointF> ekvOrig;
ekvOrig.append(QPointF(1055.89455044, 96.7531583682));
ekvOrig.append(QPointF(1408.72549102, 20.5882538362));
ekvOrig.append(QPointF(1459.81603355, 506.813077611));
ekvOrig.append(QPointF(1508.46179299, 969.771085841));
ekvOrig.append(QPointF(1455.67973006, 991.120774377));
ekvOrig.append(QPointF(1141.4155362, 589.560971108));
ekvOrig.append(QPointF(787.1898456692913, 1663.5186141732283));
ekvOrig.append(QPointF(989.3402780205395, 1663.5186141732283));
ekvOrig.append(QPointF(915.0896841461371, 1914.8556948468406));
ekvOrig.append(QPointF(894.0594908835558, 2005.5891221381557));
ekvOrig.append(QPointF(834.9361130712198, 2006.4994568398874));
ekvOrig.append(QPointF(788.9513624221928, 1832.6242224517807));
// Begin comparison
Comparison(ekv, ekvOrig);
}
//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractDetail::Case1() const
void TST_VAbstractDetail::TestCorrectEquidistantPoints_data()
{
const QVector<QPointF> points = InputPointsCase1(); // Input points.
const EquidistantType eqv = EquidistantType::CloseEquidistant; // Closed path
const qreal width = 75.5906; // seam allowance width
QTest::addColumn<QVector<QPointF>>("before");
QTest::addColumn<QVector<QPointF>>("expect");
const QVector<QPointF> ekv = VAbstractDetail::Equidistant(points, eqv, width);// Take result
const QVector<QPointF> ekvOrig = OutputPointsCase1(); // Expected result
QVector<QPointF> before;
before << QPointF(30.0, 39.999874015748034);
before << QPointF(785.9055118110236, 39.999874015748034);
before << QPointF(785.9055118110236, 3819.527433070866);
before << QPointF(483.54330708661416, 3819.527433070866);
before << QPointF(483.54330708661416, 1929.763653543307);
before << QPointF(407.9527559055629, 984.8817637795973);
before << QPointF(407.9527559055118, 1929.763653543307);
before << QPointF(407.9527559055118, 3819.527433070866);
before << QPointF(30.0, 3819.527433070866);
// Begin comparison
Comparison(ekv, ekvOrig);
QVector<QPointF> expect;
expect << QPointF(30.0, 39.999874015748034);
expect << QPointF(785.9055118110236, 39.999874015748034);
expect << QPointF(785.9055118110236, 3819.527433070866);
expect << QPointF(483.54330708661416, 3819.527433070866);
expect << QPointF(483.54330708661416, 1929.763653543307);
expect << QPointF(407.9527559055629, 984.8817637795973);
expect << QPointF(407.9527559055118, 3819.527433070866);
expect << QPointF(30.0, 3819.527433070866);
QTest::newRow("Test case issue #548") << before << expect;
}
//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractDetail::Case2() const
void TST_VAbstractDetail::TestCorrectEquidistantPoints() const
{
const QVector<QPointF> points = InputPointsCase2(); // Input points.
const EquidistantType eqv = EquidistantType::CloseEquidistant; // Closed path
const qreal width = 37.7953; // seam allowance width
QFETCH(QVector<QPointF>, before);
QFETCH(QVector<QPointF>, expect);
const QVector<QPointF> ekv = VAbstractDetail::Equidistant(points, eqv, width);// Take result
const QVector<QPointF> ekvOrig = OutputPointsCase2(); // Expected result
// Begin comparison
Comparison(ekv, ekvOrig);
QVector<QPointF> after = VAbstractDetail::CorrectEquidistantPoints(before);
Comparison(after, expect);
}
//---------------------------------------------------------------------------------------------------------------------
@ -567,41 +645,27 @@ QVector<QPointF> TST_VAbstractDetail::OutputPointsCase1() const
{
QVector<QPointF> points;
points += QPointF(-52.3725, -35.5907);
points += QPointF(487.711, -35.5907);
points += QPointF(493.343, 473.326);
points += QPointF(385.981, 506.845);
points += QPointF(345.647, 447.143);
points += QPointF(326.825, 417.766);
points += QPointF(297.492, 369.749);
points += QPointF(280.344, 340.638);
points += QPointF(268.238, 345.564);
points += QPointF(254.389, 348.788);
points += QPointF(240.894, 350.022);
points += QPointF(224.296, 349.294);
points += QPointF(205.506, 345.316);
points += QPointF(188.726, 339.383);
points += QPointF(173.487, 332.257);
points += QPointF(159.093, 324.152);
points += QPointF(145.156, 315.146);
points += QPointF(131.469, 305.281);
points += QPointF(117.936, 294.59);
points += QPointF(104.527, 283.112);
points += QPointF(91.2504, 270.888);
points += QPointF(78.1433, 257.963);
points += QPointF(65.2575, 244.383);
points += QPointF(52.6567, 230.194);
points += QPointF(40.4121, 215.44);
points += QPointF(28.6008, 200.16);
points += QPointF(17.3047, 184.387);
points += QPointF(6.61028, 168.141);
points += QPointF(-3.38943, 151.431);
points += QPointF(-12.5922, 134.245);
points += QPointF(-20.8806, 116.548);
points += QPointF(-28.1111, 98.2771);
points += QPointF(-34.0981, 79.3367);
points += QPointF(-38.4416, 60.2487);
points += QPointF(-52.3725, -35.5907);
points += QPointF(-52.3724798442221, -35.5907);
points += QPointF(487.7117748779425, -35.5907);
points += QPointF(493.3486932130227, 473.81998224542247);
points += QPointF(384.7625023736152, 506.7228642416019);
points += QPointF(326.77984549201204, 417.71265429523794);
points += QPointF(280.4343843787976, 340.220616520921);
points += QPointF(269.00223298277206, 346.06212334710335);
points += QPointF(239.6571136552229, 350.73379418002804);
points += QPointF(205.89523544191223, 345.8623563310819);
points += QPointF(173.89027296099863, 332.6512960877336);
points += QPointF(145.31523414712046, 315.34576260355936);
points += QPointF(117.9921341644787, 294.6948297428524);
points += QPointF(91.25349438209683, 270.93768759082707);
points += QPointF(65.22541125346564, 244.39379519957222);
points += QPointF(40.34791988062461, 215.4153238967542);
points += QPointF(17.205314383747528, 184.31949780808853);
points += QPointF(-3.534416178847685, 151.30687894362717);
points += QPointF(-21.090087790322336, 116.33389217738734);
points += QPointF(-33.795079640648055, 80.66898804409438);
points += QPointF(-38.441724866417594, 60.24852451858777);
points += QPointF(-52.3724798442221, -35.5907);
return points;
}
@ -685,52 +749,32 @@ QVector<QPointF> TST_VAbstractDetail::OutputPointsCase2() const
{
QVector<QPointF> points;
points += QPointF(-2.79526, 4.83848);
points += QPointF(67.3445, -0.232496);
points += QPointF(73.1172, 39.482);
points += QPointF(75.4242, 49.6203);
points += QPointF(78.7941, 60.2814);
points += QPointF(83.273, 71.5993);
points += QPointF(88.7999, 83.3999);
points += QPointF(95.2925, 95.5245);
points += QPointF(102.656, 107.829);
points += QPointF(110.787, 120.18);
points += QPointF(119.578, 132.456);
points += QPointF(128.919, 144.54);
points += QPointF(138.697, 156.322);
points += QPointF(148.796, 167.694);
points += QPointF(159.098, 178.552);
points += QPointF(169.482, 188.791);
points += QPointF(179.818, 198.308);
points += QPointF(189.972, 207);
points += QPointF(199.794, 214.759);
points += QPointF(209.115, 221.477);
points += QPointF(216.034, 225.948);
points += QPointF(215.311, 223.266);
points += QPointF(212.945, 216.109);
points += QPointF(205.759, 194.78);
points += QPointF(197.889, 169.298);
points += QPointF(193.975, 155.081);
points += QPointF(191.164, 142.904);
points += QPointF(189.364, 131.496);
points += QPointF(189.144, 117.752);
points += QPointF(194.429, 100.985);
points += QPointF(210.02, 85.4196);
points += QPointF(231.367, 81.4782);
points += QPointF(246.493, 85.8976);
points += QPointF(256.602, 92.4352);
points += QPointF(264.477, 100.216);
points += QPointF(270.989, 108.11);
points += QPointF(280.35, 121.002);
points += QPointF(294.425, 142.543);
points += QPointF(318.564, 182.007);
points += QPointF(355.648, 245.077);
points += QPointF(394.726, 311.416);
points += QPointF(422.951, 357.621);
points += QPointF(440.373, 384.812);
points += QPointF(488.279, 455.72);
points += QPointF(-2.79526, 455.75);
points += QPointF(-2.79526, 4.83848);
points += QPointF(-2.7952999999999975, 5.7719918429762656);
points += QPointF(65.32544836315374, -0.992801551243895);
points += QPointF(75.43676015393824, 49.41505784459415);
points += QPointF(83.37769389516122, 71.70650391130641);
points += QPointF(95.36495808942361, 95.58656052818594);
points += QPointF(110.83634280812595, 120.21325109595534);
points += QPointF(128.9510900596877, 144.55333805162292);
points += QPointF(148.8122943732712, 167.68860240021857);
points += QPointF(169.48075280895182, 188.76665620458672);
points += QPointF(189.9439329177606, 206.94808512857375);
points += QPointF(209.03488292644147, 221.3771186982216);
points += QPointF(215.73126220022726, 225.4325608097815);
points += QPointF(215.09342206269645, 222.63086681417994);
points += QPointF(205.6867557893074, 194.5606373284329);
points += QPointF(193.90240551299544, 154.91725528228594);
points += QPointF(189.00923093023508, 130.4332749760628);
points += QPointF(191.70730467606634, 97.53824783614445);
points += QPointF(229.19819583315143, 77.54897644999551);
points += QPointF(256.3345313737502, 91.70119126633715);
points += QPointF(270.9082046450185, 107.89162042078927);
points += QPointF(294.3626891097502, 142.42241251279827);
points += QPointF(355.51936324849004, 244.86019492195868);
points += QPointF(422.97357725399365, 357.6471728523805);
points += QPointF(486.8597146913536, 455.7199210117685);
points += QPointF(-2.795300000000013, 455.7506738094777);
points += QPointF(-2.7952999999999975, 5.7719918429762656);
return points;
}

5
src/test/ValentinaTest/tst_vabstractdetail.h
View file

@ -40,15 +40,16 @@ public:
signals:
private slots:
void EquidistantRemoveLoop_data();
void EquidistantRemoveLoop() const;
void SumTrapezoids() const;
void PathRemoveLoop_data() const;
void PathRemoveLoop() const;
void BrokenDetailEquidistant() const;
void TestCorrectEquidistantPoints_data();
void TestCorrectEquidistantPoints() const;
private:
void Case1() const;
void Case2() const;
void Case3() const;
void Case4() const;
void Case5() const;

45
src/test/ValentinaTest/tst_vdetail.cpp
View file

@ -99,40 +99,17 @@ void TST_VDetail::ClearLoop()
const QVector<QPointF> pointsEkv = detail.SeamAllowancePoints(data);
QVector<QPointF> origPoints;
origPoints.append(QPointF(42.464056596, 415.284547056));
origPoints.append(QPointF(669.471111282, 560.191213853));
origPoints.append(QPointF(669.386058691, 594.870268822));
origPoints.append(QPointF(669.853724171, 619.849997563));
origPoints.append(QPointF(670.904422406, 642.3178846));
origPoints.append(QPointF(672.476094621, 662.479332552));
origPoints.append(QPointF(674.504307528, 680.4882883));
origPoints.append(QPointF(676.923618554, 696.502389941));
origPoints.append(QPointF(679.668504965, 710.685043438));
origPoints.append(QPointF(682.675134578, 723.207854677));
origPoints.append(QPointF(685.884182534, 734.253021932));
origPoints.append(QPointF(689.244614632, 744.014989124));
origPoints.append(QPointF(692.717799245, 752.700488615));
origPoints.append(QPointF(696.244854868, 760.447827851));
origPoints.append(QPointF(701.80053872, 771.230129596));
origPoints.append(QPointF(709.490850269, 784.462136001));
origPoints.append(QPointF(713.209035073, 790.761640932));
origPoints.append(QPointF(715.012191536, 793.76372792));
origPoints.append(QPointF(718.780883478, 799.17428152));
origPoints.append(QPointF(722.57235226, 803.731752263));
origPoints.append(QPointF(726.490081061, 807.667595608));
origPoints.append(QPointF(730.558043385, 811.069205493));
origPoints.append(QPointF(734.817246318, 814.013788881));
origPoints.append(QPointF(739.318992666, 816.561622842));
origPoints.append(QPointF(744.115969332, 818.753220198));
origPoints.append(QPointF(749.253944798, 820.61090345));
origPoints.append(QPointF(754.766262359, 822.143554621));
origPoints.append(QPointF(760.671847372, 823.352504448));
origPoints.append(QPointF(766.976111339, 824.236813134));
origPoints.append(QPointF(773.673526571, 824.797038187));
origPoints.append(QPointF(780.661572758, 825.034345703));
origPoints.append(QPointF(791.720374143, 824.854420471));
origPoints.append(QPointF(825.821175407, 821.455180638));
origPoints.append(QPointF(828.685875399, 1697.30583347));
origPoints.append(QPointF(42.46405659601934, 415.2845470563871));
origPoints.append(QPointF(668.6348763356573, 559.9979528395143));
origPoints.append(QPointF(672.5077340045727, 662.2773194632347));
origPoints.append(QPointF(682.7797640244206, 723.1972585208631));
origPoints.append(QPointF(696.5440854182214, 760.8937002484754));
origPoints.append(QPointF(714.3917818918, 792.5896577365422));
origPoints.append(QPointF(730.8871996023822, 810.8059842268941));
origPoints.append(QPointF(749.7001857069857, 820.4573142312262));
origPoints.append(QPointF(774.1450140007969, 824.7139100366174));
origPoints.append(QPointF(825.8284608555382, 823.6826266774736));
origPoints.append(QPointF(828.6858753986579, 1697.305833468011));
// Begin comparison
Comparison(pointsEkv, origPoints);