689 lines
25 KiB
C++
689 lines
25 KiB
C++
/************************************************************************
|
||
**
|
||
** @file vcontainer.h
|
||
** @author Roman Telezhinsky <dismine@gmail.com>
|
||
** @date November 15, 2013
|
||
**
|
||
** @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) 2013 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 VCONTAINER_H
|
||
#define VCONTAINER_H
|
||
|
||
#include "vstandarttablerow.h"
|
||
#include "vincrementtablerow.h"
|
||
#include "../geometry/varc.h"
|
||
#include "../geometry/vsplinepath.h"
|
||
#include "../geometry/vdetail.h"
|
||
#include "../widgets/vitem.h"
|
||
|
||
/**
|
||
* @brief The VContainer class container of all variables.
|
||
*/
|
||
class VContainer
|
||
{
|
||
Q_DECLARE_TR_FUNCTIONS(VContainer)
|
||
public:
|
||
/**
|
||
* @brief VContainer create empty container
|
||
*/
|
||
VContainer();
|
||
/**
|
||
* @brief operator = copy constructor
|
||
* @param data container
|
||
* @return copy container
|
||
*/
|
||
VContainer &operator=(const VContainer &data);
|
||
/**
|
||
* @brief VContainer create container from another container
|
||
* @param data container
|
||
*/
|
||
VContainer(const VContainer &data);
|
||
/**
|
||
* @brief setData copy data from container
|
||
* @param data container
|
||
*/
|
||
void setData(const VContainer &data);
|
||
/**
|
||
* @brief GetPoint returns a point by id
|
||
* @param id id of point
|
||
* @return point
|
||
*/
|
||
VPointF GetPoint(qint64 id) const;
|
||
/**
|
||
* @brief GetPointModeling return a point modeling by id
|
||
* @param id id of point modeling
|
||
* @return point modeling
|
||
*/
|
||
VPointF GetPointModeling(qint64 id) const;
|
||
/**
|
||
* @brief GetStandartTableCell return standart table row by name
|
||
* @param name name of standart table row
|
||
* @return row of standart table
|
||
*/
|
||
VStandartTableRow GetStandartTableCell(const QString& name) const;
|
||
/**
|
||
* @brief GetIncrementTableRow return increment table row by name
|
||
* @param name name of increment table row
|
||
* @return row of increment table
|
||
*/
|
||
VIncrementTableRow GetIncrementTableRow(const QString& name) const;
|
||
/**
|
||
* @brief GetLine return length of line by name
|
||
* @param name name of line
|
||
* @return length of line in mm
|
||
*/
|
||
qreal GetLine(const QString &name) const;
|
||
/**
|
||
* @brief GetLengthArc return length of arc by name
|
||
* @param name name of arc
|
||
* @return length of arc in mm
|
||
*/
|
||
qreal GetLengthArc(const QString &name) const;
|
||
/**
|
||
* @brief GetLengthSpline return length of spline by name
|
||
* @param name name of spline
|
||
* @return length of spline in mm
|
||
*/
|
||
qreal GetLengthSpline(const QString &name) const;
|
||
/**
|
||
* @brief GetLineAngle return angle of line
|
||
* @param name name of line angle
|
||
* @return angle in degree
|
||
*/
|
||
qreal GetLineAngle(const QString &name) const;
|
||
/**
|
||
* @brief GetSpline return spline by id
|
||
* @param id id of spline
|
||
* @return spline
|
||
*/
|
||
VSpline GetSpline(qint64 id) const;
|
||
/**
|
||
* @brief GetSplineModeling return spline modeling by id
|
||
* @param id id of spline modeling
|
||
* @return spline modeling
|
||
*/
|
||
VSpline GetSplineModeling(qint64 id) const;
|
||
/**
|
||
* @brief GetArc return arc by id
|
||
* @param id id of arc
|
||
* @return arc
|
||
*/
|
||
VArc GetArc(qint64 id) const;
|
||
/**
|
||
* @brief GetArcModeling return arc modeling by id
|
||
* @param id id of arc modeling
|
||
* @return arc modeling
|
||
*/
|
||
VArc GetArcModeling(qint64 id) const;
|
||
/**
|
||
* @brief GetSplinePath return spline path by id
|
||
* @param id id of spline path
|
||
* @return spline path
|
||
*/
|
||
VSplinePath GetSplinePath(qint64 id) const;
|
||
/**
|
||
* @brief GetSplinePathModeling return spline path modeling by id
|
||
* @param id id of spline modeling path
|
||
* @return spline modeling path
|
||
*/
|
||
VSplinePath GetSplinePathModeling(qint64 id) const;
|
||
/**
|
||
* @brief GetDetail return detail by id
|
||
* @param id id of detail
|
||
* @return detail
|
||
*/
|
||
VDetail GetDetail(qint64 id) const;
|
||
/**
|
||
* @brief getId return current id
|
||
* @return current id
|
||
*/
|
||
static qint64 getId() {return _id;}
|
||
/**
|
||
* @brief AddPoint add new point to container
|
||
* @param point new point
|
||
* @return return id of new point in container
|
||
*/
|
||
qint64 AddPoint(const VPointF& point);
|
||
/**
|
||
* @brief AddPointModeling add new point modeling to container
|
||
* @param point new point modeling
|
||
* @return return id of new point modeling in container
|
||
*/
|
||
qint64 AddPointModeling(const VPointF& point);
|
||
/**
|
||
* @brief AddDetail add new detail to container
|
||
* @param detail new detail
|
||
* @return return id of new detail in container
|
||
*/
|
||
qint64 AddDetail(const VDetail& detail);
|
||
/**
|
||
* @brief AddStandartTableCell add new row of standart table
|
||
* @param name name of row of standart table
|
||
* @param cell row of standart table
|
||
*/
|
||
inline void AddStandartTableCell(const QString& name, const VStandartTableRow& cell)
|
||
{standartTable[name] = cell;}
|
||
/**
|
||
* @brief AddIncrementTableRow add new row of increment table
|
||
* @param name name of new row of increment table
|
||
* @param row new row of increment table
|
||
*/
|
||
inline void AddIncrementTableRow(const QString& name, const VIncrementTableRow &row)
|
||
{incrementTable[name] = row;}
|
||
/**
|
||
* @brief AddLengthLine add length of line to container
|
||
* @param name name of line
|
||
* @param value length of line
|
||
*/
|
||
void AddLengthLine(const QString &name, const qreal &value);
|
||
/**
|
||
* @brief AddLengthSpline add length of spline to container
|
||
* @param name name of spline
|
||
* @param value length of spline
|
||
*/
|
||
void AddLengthSpline(const QString &name, const qreal &value);
|
||
/**
|
||
* @brief AddLengthArc add length of arc to container
|
||
* @param id id of arc
|
||
*/
|
||
void AddLengthArc(const qint64 &id);
|
||
/**
|
||
* @brief AddLengthArc add length of arc
|
||
* @param name name of arc
|
||
* @param value length of arc
|
||
*/
|
||
void AddLengthArc(const QString &name, const qreal &value);
|
||
/**
|
||
* @brief AddLineAngle add angle of line to container
|
||
* @param name name of line angle
|
||
* @param value angle in degree
|
||
*/
|
||
void AddLineAngle(const QString &name, const qreal &value);
|
||
/**
|
||
* @brief AddLine add line to container
|
||
* @param firstPointId id of first point of line
|
||
* @param secondPointId id of second point of line
|
||
* @param mode mode of line
|
||
*/
|
||
void AddLine(const qint64 &firstPointId, const qint64 &secondPointId,
|
||
const Draw::Draws &mode = Draw::Calculation);
|
||
/**
|
||
* @brief AddSpline add spline to container
|
||
* @param spl new spline
|
||
* @return id of spline in container
|
||
*/
|
||
qint64 AddSpline(const VSpline& spl);
|
||
/**
|
||
* @brief AddSplineModeling add spline modeling to container
|
||
* @param spl new spline modeling
|
||
* @return id of spline modeling in container
|
||
*/
|
||
qint64 AddSplineModeling(const VSpline& spl);
|
||
/**
|
||
* @brief AddSplinePath add spline path to container
|
||
* @param splPath new spline path
|
||
* @return id of spline path in container
|
||
*/
|
||
qint64 AddSplinePath(const VSplinePath& splPath);
|
||
/**
|
||
* @brief AddSplinePathModeling add spline path modeling to container
|
||
* @param splPath new spline path
|
||
* @return id of spline path in container
|
||
*/
|
||
qint64 AddSplinePathModeling(const VSplinePath& splPath);
|
||
/**
|
||
* @brief AddArc add arc to container
|
||
* @param arc new arc
|
||
* @return id of arc in container in container
|
||
*/
|
||
qint64 AddArc(const VArc& arc);
|
||
/**
|
||
* @brief AddArcModeling add arc modeling to container
|
||
* @param arc new arc modeling
|
||
* @return id of new arc modeling in container
|
||
*/
|
||
qint64 AddArcModeling(const VArc& arc);
|
||
/**
|
||
* @brief GetNameLine return name of line
|
||
* @param firstPoint id of first point of line
|
||
* @param secondPoint id of second point of line
|
||
* @param mode mode of line
|
||
* @return name of line
|
||
*/
|
||
QString GetNameLine(const qint64 &firstPoint, const qint64 &secondPoint,
|
||
const Draw::Draws &mode = Draw::Calculation) const;
|
||
/**
|
||
* @brief GetNameLineAngle return name of line angle
|
||
* @param firstPoint id of first point of line
|
||
* @param secondPoint id of second point of line
|
||
* @param mode mode of line
|
||
* @return name of angle of line
|
||
*/
|
||
QString GetNameLineAngle(const qint64 &firstPoint, const qint64 &secondPoint,
|
||
const Draw::Draws &mode = Draw::Calculation) const;
|
||
/**
|
||
* @brief UpdatePoint update point by id
|
||
* @param id id of existing point
|
||
* @param point point
|
||
*/
|
||
void UpdatePoint(qint64 id, const VPointF& point);
|
||
/**
|
||
* @brief UpdatePointModeling update point modeling by id
|
||
* @param id id of existing point modeling
|
||
* @param point point modeling
|
||
*/
|
||
void UpdatePointModeling(qint64 id, const VPointF& point);
|
||
/**
|
||
* @brief UpdateDetail update detail by id
|
||
* @param id id of existing detail
|
||
* @param detail detail
|
||
*/
|
||
void UpdateDetail(qint64 id, const VDetail& detail);
|
||
/**
|
||
* @brief UpdateSpline update spline by id
|
||
* @param id if of existing spline
|
||
* @param spl spline
|
||
*/
|
||
void UpdateSpline(qint64 id, const VSpline& spl);
|
||
/**
|
||
* @brief UpdateSplineModeling update spline modeling by id
|
||
* @param id id of existing spline modeling
|
||
* @param spl spline modeling
|
||
*/
|
||
void UpdateSplineModeling(qint64 id, const VSpline& spl);
|
||
/**
|
||
* @brief UpdateSplinePath update spline path by id
|
||
* @param id id of existing spline path
|
||
* @param splPath spline path
|
||
*/
|
||
void UpdateSplinePath(qint64 id, const VSplinePath& splPath);
|
||
/**
|
||
* @brief UpdateSplinePathModeling update spline path modeling by id
|
||
* @param id id of existing spline path modeling
|
||
* @param splPath spline path modeling
|
||
*/
|
||
void UpdateSplinePathModeling(qint64 id, const VSplinePath& splPath);
|
||
/**
|
||
* @brief UpdateArc update arc by id
|
||
* @param id id of existing arc
|
||
* @param arc arc
|
||
*/
|
||
void UpdateArc(qint64 id, const VArc& arc);
|
||
/**
|
||
* @brief UpdateArcModeling update arc modeling by id
|
||
* @param id id of existing arc modeling
|
||
* @param arc arc modeling
|
||
*/
|
||
void UpdateArcModeling(qint64 id, const VArc& arc);
|
||
/**
|
||
* @brief UpdateStandartTableCell update standart table row by name
|
||
* @param name name of row
|
||
* @param cell row of standart table
|
||
*/
|
||
inline void UpdateStandartTableCell(const QString& name, const VStandartTableRow& cell)
|
||
{standartTable[name] = cell;}
|
||
/**
|
||
* @brief UpdateIncrementTableRow update increment table row by name
|
||
* @param name name of row
|
||
* @param row row
|
||
*/
|
||
inline void UpdateIncrementTableRow(const QString& name, const VIncrementTableRow& row)
|
||
{incrementTable[name] = row;}
|
||
/**
|
||
* @brief GetValueStandartTableCell return value of standart table row by name
|
||
* @param name name of row
|
||
* @return value in mm
|
||
*/
|
||
qreal GetValueStandartTableCell(const QString& name) const;
|
||
/**
|
||
* @brief GetValueIncrementTableRow return value of increment table row by name
|
||
* @param name name of row
|
||
* @return value of row in mm
|
||
*/
|
||
qreal GetValueIncrementTableRow(const QString& name) const;
|
||
/**
|
||
* @brief Clear clear data in container. Id will be 0.
|
||
*/
|
||
void Clear();
|
||
/**
|
||
* @brief ClearObject points, splines, arcs, spline paths will be cleared.
|
||
*/
|
||
void ClearObject();
|
||
/**
|
||
* @brief ClearIncrementTable clear increment table
|
||
*/
|
||
inline void ClearIncrementTable() {incrementTable.clear();}
|
||
/**
|
||
* @brief ClearLengthLines clear length lines
|
||
*/
|
||
inline void ClearLengthLines() {lengthLines.clear();}
|
||
/**
|
||
* @brief ClearLengthSplines clear length splines
|
||
*/
|
||
inline void ClearLengthSplines() {lengthSplines.clear();}
|
||
/**
|
||
* @brief ClearLengthArcs clear length arcs
|
||
*/
|
||
inline void ClearLengthArcs() {lengthArcs.clear();}
|
||
/**
|
||
* @brief ClearLineAngles clear angles of lines
|
||
*/
|
||
inline void ClearLineAngles() {lineAngles.clear();}
|
||
/**
|
||
* @brief SetSize set value of size
|
||
* @param size value of size in mm
|
||
*/
|
||
inline void SetSize(qint32 size) {base["Сг"] = size;}
|
||
/**
|
||
* @brief SetGrowth set value of growth
|
||
* @param growth value of growth in mm
|
||
*/
|
||
inline void SetGrowth(qint32 growth) {base["Р"] = growth;}
|
||
/**
|
||
* @brief size return size
|
||
* @return size in mm
|
||
*/
|
||
inline qint32 size() const {return base.value("Сг");}
|
||
/**
|
||
* @brief growth return growth
|
||
* @return growth in mm
|
||
*/
|
||
inline qint32 growth() const {return base.value("Р");}
|
||
/**
|
||
* @brief FindVar return value of variable by name
|
||
* @param name name of variable
|
||
* @param ok false if can't find variable
|
||
* @return value of variable
|
||
*/
|
||
qreal FindVar(const QString& name, bool *ok)const;
|
||
/**
|
||
* @brief IncrementTableContains check if increment table contains name
|
||
* @param name name of row
|
||
* @return true if contains
|
||
*/
|
||
inline bool IncrementTableContains(const QString& name) {return incrementTable.contains(name);}
|
||
/**
|
||
* @brief getNextId generate next unique id
|
||
* @return next unique id
|
||
*/
|
||
static qint64 getNextId();
|
||
/**
|
||
* @brief RemoveIncrementTableRow remove row by name from increment table
|
||
* @param name name of existing row
|
||
*/
|
||
inline void RemoveIncrementTableRow(const QString& name) {incrementTable.remove(name);}
|
||
/**
|
||
* @brief data container with dataPoints return container of points
|
||
* @return pointer on container of points
|
||
*/
|
||
inline const QHash<qint64, VPointF> *DataPoints() const {return &points;}
|
||
/**
|
||
* @brief data container with dataPointsModeling return container of points modeling
|
||
* @return pointer on container of points modeling
|
||
*/
|
||
inline const QHash<qint64, VPointF> *DataPointsModeling() const {return &pointsModeling;}
|
||
/**
|
||
* @brief data container with dataSplines return container of splines
|
||
* @return pointer on container of splines
|
||
*/
|
||
inline const QHash<qint64, VSpline> *DataSplines() const {return &splines;}
|
||
/**
|
||
* @brief data container with dataSplinesModeling return container of splines modeling
|
||
* @return pointer on container of splines modeling
|
||
*/
|
||
inline const QHash<qint64, VSpline> *DataSplinesModeling() const {return &splinesModeling;}
|
||
/**
|
||
* @brief data container with dataArcs return container of arcs
|
||
* @return pointer on container of arcs
|
||
*/
|
||
inline const QHash<qint64, VArc> *DataArcs() const {return &arcs;}
|
||
/**
|
||
* @brief data container with dataArcsModeling return container of arcs modeling
|
||
* @return pointer on container of arcs modeling
|
||
*/
|
||
inline const QHash<qint64, VArc> *DataArcsModeling() const {return &arcsModeling;}
|
||
/**
|
||
* @brief data container with dataBase return container of data
|
||
* @return pointer on container of base data
|
||
*/
|
||
inline const QHash<QString, qint32> *DataBase() const {return &base;}
|
||
/**
|
||
* @brief data container with dataStandartTable return container of standart table
|
||
* @return pointer on container of standart table
|
||
*/
|
||
inline const QHash<QString, VStandartTableRow> *DataStandartTable() const {return &standartTable;}
|
||
/**
|
||
* @brief data container with dataIncrementTable return container of increment table
|
||
* @return pointer on container of increment table
|
||
*/
|
||
inline const QHash<QString, VIncrementTableRow> *DataIncrementTable() const {return &incrementTable;}
|
||
/**
|
||
* @brief data container with dataLengthLines return container of lines lengths
|
||
* @return pointer on container of lines lengths
|
||
*/
|
||
inline const QHash<QString, qreal> *DataLengthLines() const {return &lengthLines;}
|
||
/**
|
||
* @brief data container with dataLengthSplines return container of splines lengths
|
||
* @return pointer on container of splines lengths
|
||
*/
|
||
inline const QHash<QString, qreal> *DataLengthSplines() const {return &lengthSplines;}
|
||
/**
|
||
* @brief data container with dataLengthArcs return container of arcs length
|
||
* @return pointer on container of arcs length
|
||
*/
|
||
inline const QHash<QString, qreal> *DataLengthArcs() const {return &lengthArcs;}
|
||
/**
|
||
* @brief data container with dataLineAngles return container of angles of line
|
||
* @return pointer on container of angles of line
|
||
*/
|
||
inline const QHash<QString, qreal> *DataLineAngles() const {return &lineAngles;}
|
||
/**
|
||
* @brief data container with dataSplinePaths return container of spline paths
|
||
* @return pointer on container of spline paths
|
||
*/
|
||
inline const QHash<qint64, VSplinePath> *DataSplinePaths() const {return &splinePaths;}
|
||
/**
|
||
* @brief data container with dataSplinePathsModeling return container of spline paths modeling
|
||
* @return pointer on container of spline paths modeling
|
||
*/
|
||
inline const QHash<qint64, VSplinePath> *DataSplinePathsModeling() const {return &splinePathsModeling;}
|
||
/**
|
||
* @brief data container with dataDetails return container of details
|
||
* @return pointer on container of details
|
||
*/
|
||
inline const QHash<qint64, VDetail> *DataDetails() const {return &details;}
|
||
/**
|
||
* @brief UpdateId update id. If new id bigger when current save new like current.
|
||
* @param newId id
|
||
*/
|
||
static void UpdateId(qint64 newId);
|
||
/**
|
||
* @brief ContourPath create painter path for detail
|
||
* @param idDetail id of detail
|
||
* @return return painter path of contour detail
|
||
*/
|
||
QPainterPath ContourPath(qint64 idDetail) const;
|
||
/**
|
||
* @brief biasPoints bias point
|
||
* @param points vector of points
|
||
* @param mx offset respect to x
|
||
* @param my offset respect to y
|
||
* @return new vector biased points
|
||
*/
|
||
QVector<QPointF> biasPoints(const QVector<QPointF> &points, const qreal &mx, const qreal &my) const;
|
||
/**
|
||
* @brief Equidistant create equidistant painter path for detail
|
||
* @param points vector of points
|
||
* @param eqv type of equidistant
|
||
* @param width width of equidistant
|
||
* @return return painter path of equidistant
|
||
*/
|
||
QPainterPath Equidistant(QVector<QPointF> points, const Detail::Equidistant &eqv, const qreal &width)const;
|
||
/**
|
||
* @brief ParallelLine create parallel line
|
||
* @param line starting line
|
||
* @param width width to parallel line
|
||
* @return parallel line
|
||
*/
|
||
static QLineF ParallelLine(const QLineF &line, qreal width );
|
||
/**
|
||
* @brief SingleParallelPoint return point of parallel line
|
||
* @param line starting line
|
||
* @param angle angle in degree
|
||
* @param width width to parallel line
|
||
* @return point of parallel line
|
||
*/
|
||
static QPointF SingleParallelPoint(const QLineF &line, const qreal &angle, const qreal &width);
|
||
/**
|
||
* @brief EkvPoint return vector of points of equidistant two lines. Last point of two lines must be equal.
|
||
* @param line1 first line
|
||
* @param line2 second line
|
||
* @param width width of equidistant
|
||
* @return vector of points
|
||
*/
|
||
QVector<QPointF> EkvPoint(const QLineF &line1, const QLineF &line2, const qreal &width)const;
|
||
/**
|
||
* @brief CheckLoops seek and delete loops in equidistant
|
||
* @param points vector of points of equidistant
|
||
* @return vector of points of equidistant
|
||
*/
|
||
QVector<QPointF> CheckLoops(const QVector<QPointF> &points) const;
|
||
/**
|
||
* @brief PrepareDetails prepare detail for creation layout
|
||
* @param list list of details
|
||
*/
|
||
void PrepareDetails(QVector<VItem *> & list) const;
|
||
private:
|
||
/**
|
||
* @brief _id current id. New object will have value +1. For full class equal 0.
|
||
*/
|
||
static qint64 _id;
|
||
/**
|
||
* @brief base container of base data (size and growth)
|
||
*/
|
||
QHash<QString, qint32> base;
|
||
/**
|
||
* @brief points container of points
|
||
*/
|
||
QHash<qint64, VPointF> points;
|
||
/**
|
||
* @brief pointsModeling container of points modeling
|
||
*/
|
||
QHash<qint64, VPointF> pointsModeling;
|
||
/**
|
||
* @brief standartTable container of standart table rows
|
||
*/
|
||
QHash<QString, VStandartTableRow> standartTable;
|
||
/**
|
||
* @brief incrementTable
|
||
*/
|
||
QHash<QString, VIncrementTableRow> incrementTable;
|
||
/**
|
||
* @brief lengthLines container of lines lengths
|
||
*/
|
||
QHash<QString, qreal> lengthLines;
|
||
/**
|
||
* @brief lineAngles container of angles of lines
|
||
*/
|
||
QHash<QString, qreal> lineAngles;
|
||
/**
|
||
* @brief splines container of splines
|
||
*/
|
||
QHash<qint64, VSpline> splines;
|
||
/**
|
||
* @brief splinesModeling container of splines modeling
|
||
*/
|
||
QHash<qint64, VSpline> splinesModeling;
|
||
/**
|
||
* @brief lengthSplines container of splines length
|
||
*/
|
||
QHash<QString, qreal> lengthSplines;
|
||
/**
|
||
* @brief arcs container of arcs
|
||
*/
|
||
QHash<qint64, VArc> arcs;
|
||
/**
|
||
* @brief arcsModeling container of arcs modeling
|
||
*/
|
||
QHash<qint64, VArc> arcsModeling;
|
||
/**
|
||
* @brief lengthArcs container of arcs length
|
||
*/
|
||
QHash<QString, qreal> lengthArcs;
|
||
/**
|
||
* @brief splinePaths container of spline paths
|
||
*/
|
||
QHash<qint64, VSplinePath> splinePaths;
|
||
/**
|
||
* @brief splinePathsModeling container of spline paths modeling
|
||
*/
|
||
QHash<qint64, VSplinePath> splinePathsModeling;
|
||
/**
|
||
* @brief details container of details
|
||
*/
|
||
QHash<qint64, VDetail> details;
|
||
/**
|
||
* @brief CreateManTableIGroup generate man standart table of measurements
|
||
*/
|
||
void CreateManTableIGroup ();
|
||
/**
|
||
* @brief GetReversePoint return revers container of points
|
||
* @param points container with points
|
||
* @return reverced points
|
||
*/
|
||
QVector<QPointF> GetReversePoint(const QVector<QPointF> &points)const;
|
||
/**
|
||
* @brief GetLengthContour return length of contour
|
||
* @param contour container with points of contour
|
||
* @param newPoints point whos we try to add to contour
|
||
* @return length length of contour
|
||
*/
|
||
qreal GetLengthContour(const QVector<QPointF> &contour, const QVector<QPointF> &newPoints)const;
|
||
template <typename key, typename val>
|
||
/**
|
||
* @brief GetObject return object from container
|
||
* @param obj container
|
||
* @param id id of object
|
||
* @return Object
|
||
*/
|
||
static val GetObject(const QHash<key, val> &obj, key id);
|
||
template <typename val>
|
||
/**
|
||
* @brief UpdateObject update object in container
|
||
* @param obj container
|
||
* @param id id of existing object
|
||
* @param point object
|
||
*/
|
||
static void UpdateObject(QHash<qint64, val> &obj, const qint64 &id, const val& point);
|
||
template <typename key, typename val>
|
||
/**
|
||
* @brief AddObject add object to container
|
||
* @param obj container
|
||
* @param value object
|
||
* @return id of object in container
|
||
*/
|
||
static qint64 AddObject(QHash<key, val> &obj, const val& value);
|
||
};
|
||
|
||
#endif // VCONTAINER_H
|