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

Improve creating a piece icon.

Browse source 
Add more information about contour: seam line, seam allowance, notches, grainline, internal paths.
This commit is contained in:
Roman Telezhynskyi 2021-05-27 19:52:37 +03:00
parent 82935a1f03
commit f3c0af7294
8 changed files with 108 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/app/puzzle/vpcarrouselpiece.cpp
View file

@ -76,16 +76,7 @@ void VPCarrouselPiece::RefreshSelection()
//---------------------------------------------------------------------------------------------------------------------
QIcon VPCarrouselPiece::CreatePieceIcon(const QSize &size, bool isDragIcon) const
{
QVector<QPointF> points = m_piece->GetMappedContourPoints(); // seamline
if(points.isEmpty())
{
points = m_piece->GetMappedSeamAllowancePoints(); // cutting line
}
QPolygonF shape(points);
shape << shape.first();
QRectF boundingRect = shape.boundingRect();
QRectF boundingRect = m_piece->DetailBoundingRect();
qreal canvasSize = qMax(boundingRect.height(), boundingRect.width());
QRectF canvas = QRectF(0, 0, canvasSize, canvasSize);
@ -147,7 +138,8 @@ QIcon VPCarrouselPiece::CreatePieceIcon(const QSize &size, bool isDragIcon) cons
painter.setBrush(QBrush(Qt::white));
}
painter.drawPolygon(shape);
m_piece->DrawMiniature(painter);
painter.end();
icon.addPixmap(pixmap,iconMode);

4
src/app/puzzle/vpgraphicspiece.cpp
View file

@ -106,7 +106,7 @@ void VPGraphicsPiece::Init()
// initialises the grainline
if(m_piece->IsGrainlineEnabled())
{
QVector<QPointF> grainLinepoints = m_piece->GetGrainline();
QVector<QPointF> grainLinepoints = m_piece->GetMappedGrainline();
if(!grainLinepoints.isEmpty())
{
m_grainline.moveTo(grainLinepoints.first());
@ -126,7 +126,7 @@ void VPGraphicsPiece::Init()
}
// initialises the passmarks
QVector<VLayoutPassmark> passmarks = m_piece->GetPassmarks();
QVector<VLayoutPassmark> passmarks = m_piece->GetMappedPassmarks();
for(auto &passmark : passmarks)
{
for (auto &line : passmark.lines)

2
src/app/puzzle/vppiece.cpp
View file

@ -54,7 +54,7 @@ VPPiece::VPPiece(VLayoutPiece layoutPiece): VLayoutPiece(layoutPiece)
// then translate the piece so that the top left corner of the bouding rect of the piece is at the position
// (0,0) in the sheet coordinate system
QRectF boundingRect = DetailBoundingRect();
QRectF boundingRect = MappedDetailBoundingRect();
QPointF offset = boundingRect.topLeft();
matrix = GetMatrix();
matrix.translate(-offset.x() ,-offset.y());

6
src/libs/vdxf/vdxfengine.cpp
View file

@ -771,7 +771,7 @@ void VDxfEngine::ExportAAMANotch(dx_ifaceBlock *detailBlock, const VLayoutPiece
{
if (detail.IsSeamAllowance())
{
const QVector<VLayoutPassmark> passmarks = detail.GetPassmarks();
const QVector<VLayoutPassmark> passmarks = detail.GetMappedPassmarks();
for(auto &passmark : passmarks)
{
for (auto &line : passmark.lines)
@ -788,7 +788,7 @@ void VDxfEngine::ExportAAMANotch(dx_ifaceBlock *detailBlock, const VLayoutPiece
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::ExportAAMAGrainline(dx_ifaceBlock *detailBlock, const VLayoutPiece &detail)
{
const QVector<QPointF> grainline = detail.GetGrainline();
const QVector<QPointF> grainline = detail.GetMappedGrainline();
if (grainline.count() > 1)
{
if (DRW_Entity *e = AAMALine(QLineF(grainline.first(), grainline.last()), QChar('7')))
@ -1053,7 +1053,7 @@ void VDxfEngine::ExportASTMNotch(dx_ifaceBlock *detailBlock, const VLayoutPiece
{
if (detail.IsSeamAllowance())
{
const QVector<VLayoutPassmark> passmarks = detail.GetPassmarks();
const QVector<VLayoutPassmark> passmarks = detail.GetMappedPassmarks();
for(auto &passmark : passmarks)
{
DRW_ASTMNotch *notch = new DRW_ASTMNotch();

2
src/libs/vlayout/vlayoutpaper.cpp
View file

@ -303,7 +303,7 @@ bool VLayoutPaper::SaveResult(const VBestSquare &bestResult, const VLayoutPiece
d->globalContour.SetContour(newGContour);
VCachedPositions positionChache;
QVector<QPointF> layoutPoints = workDetail.GetLayoutAllowancePoints();
QVector<QPointF> layoutPoints = workDetail.GetMappedLayoutAllowancePoints();
positionChache.boundingRect = VLayoutPiece::BoundingRect(layoutPoints);
positionChache.layoutAllowancePath = VAbstractPiece::PainterPath(layoutPoints);
d->positionsCache.append(positionChache);

103
src/libs/vlayout/vlayoutpiece.cpp
View file

@ -530,7 +530,7 @@ VLayoutPiece VLayoutPiece::Create(const VPiece &piece, vidtype id, const VContai
det.SetPriority(piece.GetPriority());
// Very important to set main path first!
if (det.ContourPath().isEmpty())
if (det.MappedContourPath().isEmpty())
{
throw VException (tr("Piece %1 doesn't have shape.").arg(piece.GetName()));
}
@ -650,11 +650,17 @@ void VLayoutPiece::SetSeamAllowancePoints(const QVector<QPointF> &points, bool s
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VLayoutPiece::GetLayoutAllowancePoints() const
QVector<QPointF> VLayoutPiece::GetMappedLayoutAllowancePoints() const
{
return Map(d->layoutAllowance);
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VLayoutPiece::GetLayoutAllowancePoints() const
{
return d->layoutAllowance;
}
//---------------------------------------------------------------------------------------------------------------------
QPointF VLayoutPiece::GetPieceTextPosition() const
{
@ -791,11 +797,17 @@ void VLayoutPiece::SetGrainline(const VGrainlineData& geom, const VContainer* pa
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VLayoutPiece::GetGrainline() const
QVector<QPointF> VLayoutPiece::GetMappedGrainline() const
{
return Map(d->grainlinePoints);
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VLayoutPiece::GetGrainline() const
{
return d->grainlinePoints;
}
//---------------------------------------------------------------------------------------------------------------------
bool VLayoutPiece::IsGrainlineEnabled() const
{
@ -956,22 +968,29 @@ int VLayoutPiece::LayoutEdgeByPoint(const QPointF &p1) const
}
//---------------------------------------------------------------------------------------------------------------------
QRectF VLayoutPiece::DetailBoundingRect() const
QRectF VLayoutPiece::MappedDetailBoundingRect() const
{
return IsSeamAllowance() && not IsSeamAllowanceBuiltIn() ? BoundingRect(GetMappedSeamAllowancePoints()) :
BoundingRect(GetMappedContourPoints());
}
//---------------------------------------------------------------------------------------------------------------------
QRectF VLayoutPiece::LayoutBoundingRect() const
QRectF VLayoutPiece::DetailBoundingRect() const
{
return BoundingRect(GetLayoutAllowancePoints());
return IsSeamAllowance() && not IsSeamAllowanceBuiltIn() ? BoundingRect(GetSeamAllowancePoints()) :
BoundingRect(GetContourPoints());
}
//---------------------------------------------------------------------------------------------------------------------
QRectF VLayoutPiece::MappedLayoutBoundingRect() const
{
return BoundingRect(GetMappedLayoutAllowancePoints());
}
//---------------------------------------------------------------------------------------------------------------------
qreal VLayoutPiece::Diagonal() const
{
const QRectF rec = LayoutBoundingRect();
const QRectF rec = MappedLayoutBoundingRect();
return qSqrt(pow(rec.height(), 2) + pow(rec.width(), 2));
}
@ -1037,11 +1056,17 @@ void VLayoutPiece::SetLayoutAllowancePoints()
}
//---------------------------------------------------------------------------------------------------------------------
QVector<VLayoutPassmark> VLayoutPiece::GetPassmarks() const
QVector<VLayoutPassmark> VLayoutPiece::GetMappedPassmarks() const
{
return Map(d->passmarks);
}
//---------------------------------------------------------------------------------------------------------------------
QVector<VLayoutPassmark> VLayoutPiece::GetPassmarks() const
{
return d->passmarks;
}
//---------------------------------------------------------------------------------------------------------------------
void VLayoutPiece::SetPassmarks(const QVector<VLayoutPassmark> &passmarks)
{
@ -1091,6 +1116,12 @@ void VLayoutPiece::SetInternalPaths(const QVector<VLayoutPiecePath> &internalPat
d->m_internalPaths = internalPaths;
}
//---------------------------------------------------------------------------------------------------------------------
QPainterPath VLayoutPiece::MappedContourPath() const
{
return d->matrix.map(ContourPath());
}
//---------------------------------------------------------------------------------------------------------------------
QPainterPath VLayoutPiece::ContourPath() const
{
@ -1099,7 +1130,7 @@ QPainterPath VLayoutPiece::ContourPath() const
// contour
if (not IsHideMainPath() || not IsSeamAllowance() || IsSeamAllowanceBuiltIn())
{
path = PainterPath(GetMappedContourPoints());
path = PainterPath(GetContourPoints());
}
// seam allowance
@ -1108,7 +1139,7 @@ QPainterPath VLayoutPiece::ContourPath() const
if (not IsSeamAllowanceBuiltIn())
{
// Draw seam allowance
QVector<QPointF>points = GetMappedSeamAllowancePoints();
QVector<QPointF>points = GetSeamAllowancePoints();
if (points.last().toPoint() != points.first().toPoint())
{
@ -1128,9 +1159,9 @@ QPainterPath VLayoutPiece::ContourPath() const
// Draw passmarks
QPainterPath passmaksPath;
const QVector<VLayoutPassmark> passmarks = GetPassmarks();
for(auto &passmark : passmarks)
for(const auto &passmark : passmarks)
{
for (auto &line : passmark.lines)
for (const auto &line : passmark.lines)
{
passmaksPath.moveTo(line.p1());
passmaksPath.lineTo(line.p2());
@ -1145,9 +1176,43 @@ QPainterPath VLayoutPiece::ContourPath() const
}
//---------------------------------------------------------------------------------------------------------------------
QPainterPath VLayoutPiece::LayoutAllowancePath() const
QPainterPath VLayoutPiece::MappedLayoutAllowancePath() const
{
return PainterPath(GetLayoutAllowancePoints());
return PainterPath(GetMappedLayoutAllowancePoints());
}
//---------------------------------------------------------------------------------------------------------------------
void VLayoutPiece::DrawMiniature(QPainter &painter)
{
painter.drawPath(ContourPath());
for (auto &path : d->m_internalPaths)
{
painter.save();
QPen pen = painter.pen();
pen.setStyle(path.PenStyle());
painter.setPen(pen);
painter.drawPath(path.GetPainterPath());
painter.restore();
}
for (auto &label : d->m_placeLabels)
{
painter.drawPath(VPlaceLabelItem::LabelShapePath(label.shape));
}
QPainterPath path;
QVector<QPointF> gPoints = GetGrainline();
path.moveTo(gPoints.at(0));
for (auto p : qAsConst(gPoints))
{
path.lineTo(p);
}
painter.drawPath(path);
}
//---------------------------------------------------------------------------------------------------------------------
@ -1157,7 +1222,7 @@ QGraphicsItem *VLayoutPiece::GetItem(bool textAsPaths) const
for (auto &path : d->m_internalPaths)
{
QGraphicsPathItem* pathItem = new QGraphicsPathItem(item);
auto* pathItem = new QGraphicsPathItem(item);
pathItem->setPath(d->matrix.map(path.GetPainterPath()));
QPen pen = pathItem->pen();
@ -1166,9 +1231,9 @@ QGraphicsItem *VLayoutPiece::GetItem(bool textAsPaths) const
pathItem->setPen(pen);
}
for (auto &label : d->m_placeLabels)
for (const auto &label : d->m_placeLabels)
{
QGraphicsPathItem* pathItem = new QGraphicsPathItem(item);
auto* pathItem = new QGraphicsPathItem(item);
QPen pen = pathItem->pen();
pen.setWidthF(VAbstractApplication::VApp()->Settings()->WidthHairLine());
pathItem->setPen(pen);
@ -1341,7 +1406,7 @@ void VLayoutPiece::CreateGrainlineItem(QGraphicsItem *parent) const
QPainterPath path;
QVector<QPointF> gPoints = GetGrainline();
QVector<QPointF> gPoints = GetMappedGrainline();
path.moveTo(gPoints.at(0));
for (auto p : qAsConst(gPoints))
{
@ -1370,7 +1435,7 @@ QGraphicsPathItem *VLayoutPiece::GetMainItem() const
QPen pen = item->pen();
pen.setWidthF(VAbstractApplication::VApp()->Settings()->WidthHairLine());
item->setPen(pen);
item->setPath(ContourPath());
item->setPath(MappedContourPath());
return item;
}

11
src/libs/vlayout/vlayoutpiece.h
View file

@ -82,9 +82,11 @@ public:
void SetSeamAllowancePoints(const QVector<QPointF> &points, bool seamAllowance = true,
bool seamAllowanceBuiltIn = false);
QVector<QPointF> GetMappedLayoutAllowancePoints() const;
QVector<QPointF> GetLayoutAllowancePoints() const;
void SetLayoutAllowancePoints();
QVector<VLayoutPassmark> GetMappedPassmarks() const;
QVector<VLayoutPassmark> GetPassmarks() const;
void SetPassmarks(const QVector<VLayoutPassmark> &passmarks);
@ -105,6 +107,7 @@ public:
const VContainer *pattern);
void SetGrainline(const VGrainlineData& geom, const VContainer *pattern);
QVector<QPointF> GetMappedGrainline() const;
QVector<QPointF> GetGrainline() const;
bool IsGrainlineEnabled() const;
qreal GrainlineAngle() const;
@ -137,8 +140,9 @@ public:
QLineF LayoutEdge(int i) const;
int LayoutEdgeByPoint(const QPointF &p1) const;
QRectF MappedDetailBoundingRect() const;
QRectF DetailBoundingRect() const;
QRectF LayoutBoundingRect() const;
QRectF MappedLayoutBoundingRect() const;
qreal Diagonal() const;
static QRectF BoundingRect(QVector<QPointF> points);
@ -146,8 +150,11 @@ public:
bool isNull() const;
qint64 Square() const;
QPainterPath MappedContourPath() const;
QPainterPath ContourPath() const;
QPainterPath LayoutAllowancePath() const;
QPainterPath MappedLayoutAllowancePath() const;
void DrawMiniature(QPainter &painter);
Q_REQUIRED_RESULT QGraphicsItem *GetItem(bool textAsPaths) const;

10
src/libs/vlayout/vposition.cpp
View file

@ -299,7 +299,7 @@ void VPosition::SaveCandidate(VBestSquare &bestResult, const VLayoutPiece &detai
QVector<QPointF> newGContour = m_data.gContour.UniteWithContour(detail, globalI, detJ, type);
newGContour.append(newGContour.first());
const QSizeF size = QPolygonF(newGContour).boundingRect().size();
const QRectF boundingRect = detail.DetailBoundingRect();
const QRectF boundingRect = detail.MappedDetailBoundingRect();
const qreal depthPosition = m_data.isOriginPaperOrientationPortrait ? boundingRect.y() : boundingRect.x();
const qreal sidePosition = m_data.isOriginPaperOrientationPortrait ? boundingRect.x() : boundingRect.y();
@ -332,7 +332,7 @@ bool VPosition::CheckCombineEdges(VLayoutPiece &detail, int j, int &dEdge)
#endif
CrossingType type = CrossingType::Intersection;
if (not detail.IsForceFlipping() && SheetContains(detail.DetailBoundingRect()))
if (not detail.IsForceFlipping() && SheetContains(detail.MappedDetailBoundingRect()))
{
if (not m_data.gContour.GetContour().isEmpty())
{
@ -375,7 +375,7 @@ bool VPosition::CheckCombineEdges(VLayoutPiece &detail, int j, int &dEdge)
}
CrossingType type = CrossingType::Intersection;
if (SheetContains(detail.DetailBoundingRect()))
if (SheetContains(detail.MappedDetailBoundingRect()))
{
type = Crossing(detail);
}
@ -417,7 +417,7 @@ bool VPosition::CheckRotationEdges(VLayoutPiece &detail, int j, int dEdge, qreal
#endif
CrossingType type = CrossingType::Intersection;
if (SheetContains(detail.DetailBoundingRect()))
if (SheetContains(detail.MappedDetailBoundingRect()))
{
type = Crossing(detail);
}
@ -469,7 +469,7 @@ VPosition::CrossingType VPosition::Crossing(const VLayoutPiece &detail) const
return CrossingType::NoIntersection;
}
const QVector<QPointF> layoutPoints = detail.GetLayoutAllowancePoints();
const QVector<QPointF> layoutPoints = detail.GetMappedLayoutAllowancePoints();
const QRectF layoutBoundingRect = VLayoutPiece::BoundingRect(layoutPoints);
const QPainterPath layoutAllowancePath = VAbstractPiece::PainterPath(layoutPoints);