SvgMeshArray Class Reference

#include <SvgMeshArray.h>

Public Member Functions
bool	addPatch (QList< QPair< QString, QColor > > stops, const QPointF initialPoint)
QRectF	boundingRect () const
void	createDefaultMesh (const int nrows, const int ncols, const QColor color, const QSizeF size)
	creates a default mesh in OBB coordinates (because it's easier and more logical in this case)
QVector< SvgMeshPosition >	getConnectedPaths (const SvgMeshPosition &position) const
	Return the paths connected to the corner. Can be thought of as edges connected to a vertex.
SvgMeshPatch *	getPatch (const int row, const int col) const
std::array< QPointF, 4 >	getPath (const SvgMeshPatch::Type edge, const int row, const int col) const
	Get the Path Points for a segment of the meshpatch.
SvgMeshPath	getPath (const SvgMeshPosition &pos) const
SvgMeshStop	getStop (const SvgMeshPatch::Type edge, const int row, const int col) const
	Get the point of a node in mesharray.
SvgMeshStop	getStop (const SvgMeshPosition &pos) const
void	modifyColor (const SvgMeshPosition &position, const QColor &color)
void	modifyCorner (const SvgMeshPosition &position, const QPointF &newPos)
void	modifyHandle (const SvgMeshPosition &position, const std::array< QPointF, 4 > &newPath)
void	newRow ()
int	numColumns () const
int	numRows () const
void	setTransform (const QTransform &matrix)
	SvgMeshArray ()
	SvgMeshArray (const SvgMeshArray &other)
	~SvgMeshArray ()

Private Member Functions
QColor	getColor (SvgMeshPatch::Type edge, int row, int col) const
QVector< SvgMeshPosition >	getSharedPaths (const SvgMeshPosition &position) const

Private Attributes
QVector< QVector< SvgMeshPatch * > >	m_array
	where each vector is a meshrow

Detailed Description

Definition at line 37 of file SvgMeshArray.h.

Constructor & Destructor Documentation

SvgMeshArray() [1/2]

SvgMeshArray::SvgMeshArray

(

)

Definition at line 11 of file SvgMeshArray.cpp.

{
}

SvgMeshArray() [2/2]

SvgMeshArray::SvgMeshArray

(

const SvgMeshArray &

other

)

Definition at line 15 of file SvgMeshArray.cpp.

{
    for (const auto& row: other.m_array) {
        newRow();
        for (const auto& patch: row) {
            m_array.last().append(new SvgMeshPatch(*patch));
        }
    }
}

References m_array, and newRow().

~SvgMeshArray()

SvgMeshArray::~SvgMeshArray

(

)

Definition at line 25 of file SvgMeshArray.cpp.

{
    for (auto& row: m_array) {
        for (auto& patch: row) {
            delete patch;
        }
    }
}

References m_array.

Member Function Documentation

addPatch()

bool SvgMeshArray::addPatch	(	QList< QPair< QString, QColor > >	stops,
		const QPointF	initialPoint )

Definition at line 96 of file SvgMeshArray.cpp.

{
    // This is function is full of edge-case landmines, please run TestMeshArray after any changes
    if (stops.size() > 4 || stops.size() < 2)
        return false;
 
    SvgMeshPatch *patch = new SvgMeshPatch(initialPoint);
 
     m_array.last().append(patch);
 
    int irow = m_array.size() - 1;
    int icol = m_array.last().size() - 1;
 
    if (irow == 0 && icol == 0) {
        patch->addStop(stops[0].first, stops[0].second, SvgMeshPatch::Top);
        stops.removeFirst();
    } else if (irow == 0) {
        // For first row, parse patches
        patch->addStop(stops[0].first, getColor(SvgMeshPatch::Right, irow, icol - 1), SvgMeshPatch::Top);
        stops.removeFirst();
    } else {
        // path is already defined for rows >= 1
        QColor color = getStop(SvgMeshPatch::Left, irow - 1, icol).color;
 
        std::array<QPointF, 4> points = getPath(SvgMeshPatch::Bottom, irow - 1, icol);
        std::reverse(points.begin(), points.end());
 
        patch->addStop(points, color, SvgMeshPatch::Top);
    }
 
    if (irow > 0) {
        patch->addStop(stops[0].first, getColor(SvgMeshPatch::Bottom, irow - 1, icol), SvgMeshPatch::Right);
        stops.removeFirst();
    } else {
        patch->addStop(stops[0].first, stops[0].second, SvgMeshPatch::Right);
        stops.removeFirst();
    }
 
    if (icol > 0) {
        patch->addStop(
                stops[0].first,
                stops[0].second,
                SvgMeshPatch::Bottom,
                true, getStop(SvgMeshPatch::Bottom, irow, icol - 1).point);
        stops.removeFirst();
    } else {
        patch->addStop(stops[0].first, stops[0].second, SvgMeshPatch::Bottom);
        stops.removeFirst();
    }
 
    // last stop
    if (icol == 0) {
        // if stop is in the 0th column, parse path
        patch->addStop(
                stops[0].first,
                stops[0].second,
                SvgMeshPatch::Left,
                true, getStop(SvgMeshPatch::Top, irow, icol).point);
        stops.removeFirst();
    } else {
        QColor color = getStop(SvgMeshPatch::Bottom, irow, icol - 1).color;
 
        // reuse Right side of the previous patch
        std::array<QPointF, 4> points = getPath(SvgMeshPatch::Right, irow, icol - 1);
        std::reverse(points.begin(), points.end());
 
        patch->addStop(points, color, SvgMeshPatch::Left);
    }
    return true;
}

References SvgMeshPatch::addStop(), SvgMeshPatch::Bottom, SvgMeshStop::color, getColor(), getPath(), getStop(), SvgMeshPatch::Left, m_array, SvgMeshPatch::Right, and SvgMeshPatch::Top.

boundingRect()

QRectF SvgMeshArray::boundingRect

(

)

const

Definition at line 238 of file SvgMeshArray.cpp.

{
    KIS_ASSERT(numRows() > 0 && numColumns() > 0);
 
    QPointF topLeft = m_array[0][0]->boundingRect().topLeft();
    QPointF bottomRight = m_array.last().last()->boundingRect().bottomRight();
 
    // mesharray may be backwards, in which case we might get the right most value
    // but we need topLeft for things to work as expected
    for (int i = 0; i < numRows(); ++i) {
        for (int j = 0; j < numColumns(); ++j) {
            QPointF left  = m_array[i][j]->boundingRect().topLeft();
            if (left.x() < topLeft.x()) {
                topLeft.rx() = left.x();
            }
            if ( left.y() < topLeft.y()) {
                topLeft.ry() = left.y();
            }
 
            QPointF right = m_array[i][j]->boundingRect().bottomRight();
            if (bottomRight.x() < right.x()) {
                bottomRight.rx() = right.x();
            }
            if (bottomRight.y() < right.y()) {
                bottomRight.ry() = right.y();
            }
        }
    }
 
    // return extremas
    return QRectF(topLeft, bottomRight);
}

References KIS_ASSERT, m_array, numColumns(), and numRows().

createDefaultMesh()

void SvgMeshArray::createDefaultMesh	(	const int	nrows,
		const int	ncols,
		const QColor	color,
		const QSizeF	size )

creates a default mesh in OBB coordinates (because it's easier and more logical in this case)

Definition at line 39 of file SvgMeshArray.cpp.

{
    // individual patch size should be:
    qreal patchWidth  = size.width()  / ncols;
    qreal patchHeight = size.height() / nrows;
 
    // normalize
    patchWidth  /= size.width();
    patchHeight /= size.height();
 
    QRectF start(0, 0, patchWidth, patchHeight);
 
    QColor colors[2] = {Qt::white, color};
 
    for (int irow = 0; irow < nrows; ++irow) {
        newRow();
 
        for (int icol = 0; icol < ncols; ++icol) {
            SvgMeshPatch *patch = new SvgMeshPatch(start.topLeft());
            // alternate between colors
            int index = (irow + icol) % 2;
 
            patch->addStopLinear({start.topLeft(), start.topRight()},
                                 colors[index],
                                 SvgMeshPatch::Top);
 
            index = (index + 1) % 2;
            patch->addStopLinear({start.topRight(), start.bottomRight()},
                                 colors[index],
                                 SvgMeshPatch::Right);
 
            index = (index + 1) % 2;
            patch->addStopLinear({start.bottomRight(), start.bottomLeft()},
                                 colors[index],
                                 SvgMeshPatch::Bottom);
 
            index = (index + 1) % 2;
            patch->addStopLinear({start.bottomLeft(), start.topLeft()},
                                 colors[index],
                                 SvgMeshPatch::Left);
 
            m_array.last().append(patch);
 
            // TopRight of the previous patch in this row
            start.setX(patch->getStop(SvgMeshPatch::Right).point.x());
            start.setWidth(patchWidth);
        }
 
        // BottomLeft of the patch is the starting point for new row
        start.setTopLeft(m_array.last().first()->getStop(SvgMeshPatch::Left).point);
        start.setSize({patchWidth, patchHeight});
    }
}

References SvgMeshPatch::addStopLinear(), SvgMeshPatch::Bottom, SvgMeshPatch::getStop(), SvgMeshPatch::Left, m_array, newRow(), SvgMeshStop::point, SvgMeshPatch::Right, and SvgMeshPatch::Top.

getColor()

QColor SvgMeshArray::getColor ( SvgMeshPatch::Type edge, int row, int col ) const

private

Definition at line 380 of file SvgMeshArray.cpp.

{
    return getStop(edge, row, col).color;
}

References SvgMeshStop::color, and getStop().

getConnectedPaths()

QVector< SvgMeshPosition > SvgMeshArray::getConnectedPaths

(

const SvgMeshPosition &

position

)

const

Return the paths connected to the corner. Can be thought of as edges connected to a vertex.

Definition at line 271 of file SvgMeshArray.cpp.

{
    QVector<SvgMeshPosition> positions;
 
    int row = position.row;
    int col = position.col;
    SvgMeshPatch::Type type = position.segmentType;
 
    SvgMeshPatch::Type nextType = static_cast<SvgMeshPatch::Type>(type + 1);
    SvgMeshPatch::Type previousType = static_cast<SvgMeshPatch::Type>((SvgMeshPatch::Size + type - 1) % SvgMeshPatch::Size);
 
    if (type == SvgMeshPatch::Top) {
        if (row == 0) {
            if (col > 0) {
                positions << SvgMeshPosition {row, col - 1, type};
            }
        } else {
            if (col > 0) {
                positions << SvgMeshPosition {row, col - 1, type};
                positions << SvgMeshPosition {row - 1, col - 1, nextType};
            }
            positions << SvgMeshPosition {row - 1, col, previousType};
        }
    } else if (type == SvgMeshPatch::Right && row > 0) {
        positions << SvgMeshPosition {row - 1, col, type};
 
    } else if (type == SvgMeshPatch::Left && col > 0) {
        positions << SvgMeshPosition {row, col - 1, previousType};
    }
 
    positions << SvgMeshPosition {row, col, previousType};
    positions << SvgMeshPosition {row, col, type};
 
    return positions;
}

References SvgMeshPosition::col, SvgMeshPatch::Left, SvgMeshPatch::Right, SvgMeshPosition::row, SvgMeshPosition::segmentType, SvgMeshPatch::Size, and SvgMeshPatch::Top.

getPatch()

SvgMeshPatch * SvgMeshArray::getPatch	(	const int	row,
		const int	col ) const

Definition at line 209 of file SvgMeshArray.cpp.

{
    KIS_ASSERT(row < m_array.size() && col < m_array[row].size()
            && row >= 0 && col >= 0);
 
    return m_array[row][col];
}

References KIS_ASSERT, and m_array.

getPath() [1/2]

std::array< QPointF, 4 > SvgMeshArray::getPath	(	const SvgMeshPatch::Type	edge,
		const int	row,
		const int	col ) const

Get the Path Points for a segment of the meshpatch.

Definition at line 196 of file SvgMeshArray.cpp.

{
    KIS_ASSERT(row < m_array.size() && col < m_array[row].size()
            && row >= 0 && col >= 0);
 
    return m_array[row][col]->getSegment(edge);
}

References KIS_ASSERT, and m_array.

getPath() [2/2]

SvgMeshPath SvgMeshArray::getPath

(

const SvgMeshPosition &

pos

)

const

Definition at line 204 of file SvgMeshArray.cpp.

{
    return getPath(pos.segmentType, pos.row, pos.col);
}

References SvgMeshPosition::col, getPath(), SvgMeshPosition::row, and SvgMeshPosition::segmentType.

getSharedPaths()

QVector< SvgMeshPosition > SvgMeshArray::getSharedPaths ( const SvgMeshPosition & position ) const

private

return the shared path between two patches. NOTE: Not to be confused with getConnectedPaths

Definition at line 345 of file SvgMeshArray.cpp.

{
    QVector<SvgMeshPosition> positions;
 
    int row = position.row;
    int col = position.col;
    SvgMeshPatch::Type type = position.segmentType;
 
    SvgMeshPatch::Type nextType = static_cast<SvgMeshPatch::Type>(type + 1);
    SvgMeshPatch::Type previousType = static_cast<SvgMeshPatch::Type>((SvgMeshPatch::Size + type - 1) % SvgMeshPatch::Size);
 
    if (type == SvgMeshPatch::Top) {
        if (row == 0) {
            if (col > 0) {
                positions << SvgMeshPosition {row, col - 1, nextType};
            }
        } else {
            if (col > 0) {
                positions << SvgMeshPosition {row, col - 1, nextType};
                positions << SvgMeshPosition {row - 1, col - 1, SvgMeshPatch::Bottom};
            }
            positions << SvgMeshPosition {row - 1, col, previousType};
        }
    } else if (type == SvgMeshPatch::Right && row > 0) {
        positions << SvgMeshPosition {row - 1, col, nextType};
 
    } else if (type == SvgMeshPatch::Left && col > 0) {
        positions << SvgMeshPosition {row, col - 1, previousType};
    }
 
    positions << SvgMeshPosition {row, col, type};
 
    return positions;
}

References SvgMeshPatch::Bottom, SvgMeshPosition::col, SvgMeshPatch::Left, SvgMeshPatch::Right, SvgMeshPosition::row, SvgMeshPosition::segmentType, SvgMeshPatch::Size, and SvgMeshPatch::Top.

getStop() [1/2]

SvgMeshStop SvgMeshArray::getStop	(	const SvgMeshPatch::Type	edge,
		const int	row,
		const int	col ) const

Get the point of a node in mesharray.

Definition at line 167 of file SvgMeshArray.cpp.

{
    KIS_ASSERT(row < m_array.size() && col < m_array[row].size()
            && row >= 0 && col >= 0);
 
    SvgMeshPatch *patch = m_array[row][col];
    SvgMeshStop node = patch->getStop(edge);
 
    if (node.isValid()) {
        return node;
    }
 
    switch (patch->countPoints()) {
    case 3:
    case 2:
        if (edge == SvgMeshPatch::Top)
            return getStop(SvgMeshPatch::Left, row - 1, col);
        else if (edge == SvgMeshPatch::Left)
            return getStop(SvgMeshPatch::Bottom, row, col - 1);
    }
    Q_ASSERT(false);
    return SvgMeshStop();
}

References SvgMeshPatch::Bottom, SvgMeshPatch::countPoints(), getStop(), SvgMeshPatch::getStop(), SvgMeshStop::isValid(), KIS_ASSERT, SvgMeshPatch::Left, m_array, and SvgMeshPatch::Top.

getStop() [2/2]

SvgMeshStop SvgMeshArray::getStop

(

const SvgMeshPosition &

pos

)

const

Definition at line 191 of file SvgMeshArray.cpp.

{
    return getStop(pos.segmentType, pos.row, pos.col);
}

References SvgMeshPosition::col, getStop(), SvgMeshPosition::row, and SvgMeshPosition::segmentType.

modifyColor()

void SvgMeshArray::modifyColor	(	const SvgMeshPosition &	position,
		const QColor &	color )

Definition at line 336 of file SvgMeshArray.cpp.

{
    QVector<SvgMeshPosition> paths = getSharedPaths(position);
 
    for (const auto &path: paths) {
        m_array[path.row][path.col]->setStopColor(path.segmentType, color);
    }
}

References getSharedPaths(), and m_array.

modifyCorner()

void SvgMeshArray::modifyCorner	(	const SvgMeshPosition &	position,
		const QPointF &	newPos )

Definition at line 324 of file SvgMeshArray.cpp.

{
    QVector<SvgMeshPosition> paths = getSharedPaths(position);
 
    QPointF delta = m_array[position.row][position.col]->getStop(position.segmentType).point - newPos;
 
    for (const auto &path: paths) {
        m_array[path.row][path.col]->modifyCorner(path.segmentType, delta);
    }
}

References SvgMeshPosition::col, getSharedPaths(), m_array, SvgMeshPosition::row, and SvgMeshPosition::segmentType.

modifyHandle()

void SvgMeshArray::modifyHandle	(	const SvgMeshPosition &	position,
		const std::array< QPointF, 4 > &	newPath )

Definition at line 307 of file SvgMeshArray.cpp.

{
    std::array<QPointF, 4> reversed = newPath;
    std::reverse(reversed.begin(), reversed.end());
 
    if (position.segmentType == SvgMeshPatch::Top && position.row > 0) {
        // modify the shared side
        m_array[position.row - 1][position.col]->modifyPath(SvgMeshPatch::Bottom, reversed);
 
    } else if (position.segmentType == SvgMeshPatch::Left && position.col > 0) {
        // modify the shared side as well
        m_array[position.row][position.col - 1]->modifyPath(SvgMeshPatch::Right, reversed);
    }
    m_array[position.row][position.col]->modifyPath(position.segmentType, newPath);
}

References SvgMeshPatch::Bottom, SvgMeshPosition::col, SvgMeshPatch::Left, m_array, SvgMeshPatch::Right, SvgMeshPosition::row, SvgMeshPosition::segmentType, and SvgMeshPatch::Top.

newRow()

void SvgMeshArray::newRow

(

)

Definition at line 34 of file SvgMeshArray.cpp.

{
    m_array << QVector<SvgMeshPatch*>();
}

numColumns()

int SvgMeshArray::numColumns

(

)

const

Definition at line 222 of file SvgMeshArray.cpp.

{
    if (m_array.isEmpty())
        return 0;
    return m_array.first().size();
}

References m_array.

numRows()

int SvgMeshArray::numRows

(

)

const

Definition at line 217 of file SvgMeshArray.cpp.

{
    return m_array.size();
}

References m_array.

setTransform()

void SvgMeshArray::setTransform

(

const QTransform &

matrix

)

Definition at line 229 of file SvgMeshArray.cpp.

{
    for (auto& row: m_array) {
        for (auto& patch: row) {
            patch->setTransform(matrix);
        }
    }
}

References m_array.

Member Data Documentation

m_array

QVector<QVector<SvgMeshPatch*> > SvgMeshArray::m_array

private

where each vector is a meshrow

Definition at line 91 of file SvgMeshArray.h.

---

The documentation for this class was generated from the following files:

• libs/flake/svg/SvgMeshArray.h
• libs/flake/svg/SvgMeshArray.cpp