SvgMeshPatch Class Reference

#include <SvgMeshPatch.h>

Public Types
enum	Type {   Top = 0 , Right , Bottom , Left ,   Size }
	Position of stop in the patch. More...

Public Member Functions
void	addStop (const QString &pathStr, QColor color, Type edge, bool pathIncomplete=false, QPointF lastPoint=QPointF())
void	addStop (const std::array< QPointF, 4 > &pathPoints, QColor color, Type edge)
	Adds path to the shape.
void	addStopLinear (const std::array< QPointF, 2 > &pathPoints, QColor color, Type edge)
	Adds linear path to the shape.
QRectF	boundingRect () const
int	countPoints () const
void	curveTo (const QPointF &c1, const QPointF &c2, const QPointF &p)
	add points as curve.
std::array< QPointF, 4 >	getMidCurve (bool isVertical) const
	Gets the curve passing through the middle of meshpatch.
QPointF	getMidpointParametric (Type type) const
	returns the midPoint in parametric space
QPainterPath	getPath () const
	Get full (closed) meshpath.
std::array< QPointF, 4 >	getSegment (Type type) const
	Get a segment of the path in the meshpatch.
SvgMeshStop	getStop (Type type) const
	returns the starting point of the stop
bool	isDivisibleHorizontally () const
bool	isDivisibleVertically () const
void	lineTo (const QPointF &p)
	Helper to convert to a cubic curve internally.
void	modifyCorner (SvgMeshPatch::Type type, const QPointF &delta)
void	modifyPath (SvgMeshPatch::Type type, std::array< QPointF, 4 > newPath)
void	moveTo (const QPointF &p)
QPointF	segmentPointAt (Type type, qreal t) const
	get the point on a segment using De Casteljau's algorithm
QPair< std::array< QPointF, 4 >, std::array< QPointF, 4 > >	segmentSplitAt (Type type, qreal t) const
	split a segment using De Casteljau's algorithm
void	setStopColor (SvgMeshPatch::Type type, const QColor &color)
void	setTransform (const QTransform &matrix)
QSizeF	size () const
	Get size swept by mesh in pts.
void	subdivide (QVector< SvgMeshPatch * > &subdivided, const QVector< QColor > &colors) const
void	subdivideHorizontally (QVector< SvgMeshPatch * > &subdivided, const QVector< QColor > &colors) const
void	subdivideVertically (QVector< SvgMeshPatch * > &subdivided, const QVector< QColor > &colors) const
	SvgMeshPatch (const SvgMeshPatch &other)
	SvgMeshPatch (QPointF startingPoint)

Private Member Functions
const char *	getCoord (const char *ptr, qreal &number)
QPointF	parseMeshPath (const QString &path, bool pathIncomplete=false, const QPointF lastPoint=QPointF())

Private Attributes
std::array< std::array< QPointF, 4 >, 4 >	controlPoints
int	counter {0}
bool	m_newPath
std::array< SvgMeshStop, Size >	m_nodes
std::array< QPointF, 4 >	m_parametricCoords
	Coordinates in UV space.
QPointF	m_startingPoint
	This is the starting point for each path.

Detailed Description

Definition at line 35 of file SvgMeshPatch.h.

Member Enumeration Documentation

Type

enum SvgMeshPatch::Type

Position of stop in the patch.

Enumerator
Top
Right
Bottom
Left
Size

Definition at line 39 of file SvgMeshPatch.h.

              {
        Top = 0,
        Right,
        Bottom,
        Left,
        Size,
    };

Constructor & Destructor Documentation

SvgMeshPatch() [1/2]

SvgMeshPatch::SvgMeshPatch

(

QPointF

startingPoint

)

Definition at line 62 of file SvgMeshPatch.cpp.

    : m_newPath(true)
    , m_startingPoint(startingPoint)
    , m_parametricCoords({QPointF(0, 0), {1, 0}, {1, 1}, {0, 1}})
{
}

SvgMeshPatch() [2/2]

SvgMeshPatch::SvgMeshPatch

(

const SvgMeshPatch &

other

)

Definition at line 69 of file SvgMeshPatch.cpp.

    : m_newPath(other.m_newPath)
    , m_startingPoint(other.m_startingPoint)
    , m_nodes(other.m_nodes)
    , controlPoints(other.controlPoints)
    , m_parametricCoords({QPointF(0, 0), {1, 0}, {1, 1}, {0, 1}})
{
}

Member Function Documentation

addStop() [1/2]

void SvgMeshPatch::addStop	(	const QString &	pathStr,
		QColor	color,
		Type	edge,
		bool	pathIncomplete = false,
		QPointF	lastPoint = QPointF() )

Definition at line 466 of file SvgMeshPatch.cpp.

{
    SvgMeshStop node(color, m_startingPoint);
    m_nodes[edge] = node;
 
    m_startingPoint = parseMeshPath(pathStr, pathIncomplete, lastPoint);
}

References m_nodes, m_startingPoint, and parseMeshPath().

addStop() [2/2]

void SvgMeshPatch::addStop	(	const std::array< QPointF, 4 > &	pathPoints,
		QColor	color,
		Type	edge )

Adds path to the shape.

Definition at line 478 of file SvgMeshPatch.cpp.

{
    SvgMeshStop stop(color, pathPoints[0]);
    m_nodes[edge] = stop;
 
    if (edge == SvgMeshPatch::Top) {
        moveTo(pathPoints[0]);
        m_newPath = false;
    }
 
    curveTo(pathPoints[1], pathPoints[2], pathPoints[3]);
    m_startingPoint = pathPoints[3];
}

References curveTo(), m_newPath, m_nodes, m_startingPoint, moveTo(), and Top.

addStopLinear()

void SvgMeshPatch::addStopLinear	(	const std::array< QPointF, 2 > &	pathPoints,
		QColor	color,
		Type	edge )

Adds linear path to the shape.

Definition at line 493 of file SvgMeshPatch.cpp.

{
    SvgMeshStop stop(color, pathPoints[0]);
    m_nodes[edge] = stop;
 
    if (edge == SvgMeshPatch::Top) {
        moveTo(pathPoints[0]);
        m_newPath = false;
    }
 
    lineTo(pathPoints[1]);
    m_startingPoint = pathPoints[1];
}

References lineTo(), m_newPath, m_nodes, m_startingPoint, moveTo(), and Top.

boundingRect()

QRectF SvgMeshPatch::boundingRect

(

)

const

Definition at line 135 of file SvgMeshPatch.cpp.

{
    return getPath().boundingRect();
}

References getPath().

countPoints()

int SvgMeshPatch::countPoints

(

)

const

Definition at line 539 of file SvgMeshPatch.cpp.

{
    return m_nodes.size();
}

References m_nodes.

curveTo()

void SvgMeshPatch::curveTo	(	const QPointF &	c1,
		const QPointF &	c2,
		const QPointF &	p )

add points as curve.

Definition at line 93 of file SvgMeshPatch.cpp.

{
    controlPoints[counter][1] = c1;
    controlPoints[counter][2] = c2;
    controlPoints[counter][3] = p;
    counter++;
    if (counter < Size)
        controlPoints[counter][0] = p;
}

References controlPoints, counter, p, and Size.

getCoord()

const char * SvgMeshPatch::getCoord ( const char * ptr, qreal & number )

private

Definition at line 630 of file SvgMeshPatch.cpp.

{
    // copied from KoPathShapeLoader, see the copyright above
    int integer, exponent;
    qreal decimal, frac;
    int sign, expsign;
 
    exponent = 0;
    integer = 0;
    frac = 1.0;
    decimal = 0;
    sign = 1;
    expsign = 1;
 
    // read the sign
    if (*ptr == '+')
        ++ptr;
    else if (*ptr == '-') {
        ++ptr;
        sign = -1;
    }
 
    // read the integer part
    while (*ptr != '\0' && *ptr >= '0' && *ptr <= '9')
        integer = (integer * 10) + *(ptr++) - '0';
    if (*ptr == '.') { // read the decimals
        ++ptr;
        while (*ptr != '\0' && *ptr >= '0' && *ptr <= '9')
            decimal += (*(ptr++) - '0') * (frac *= 0.1);
    }
 
    if (*ptr == 'e' || *ptr == 'E') { // read the exponent part
        ++ptr;
 
        // read the sign of the exponent
        if (*ptr == '+')
            ++ptr;
        else if (*ptr == '-') {
            ++ptr;
            expsign = -1;
        }
 
        exponent = 0;
        while (*ptr != '\0' && *ptr >= '0' && *ptr <= '9') {
            exponent *= 10;
            exponent += *ptr - '0';
            ++ptr;
        }
    }
    number = integer + decimal;
    number *= sign * pow((qreal)10, qreal(expsign * exponent));
 
    // skip the following space
    if (*ptr == ' ')
        ++ptr;
 
    return ptr;
}

References sign().

getMidCurve()

std::array< QPointF, 4 > SvgMeshPatch::getMidCurve

(

bool

isVertical

)

const

Gets the curve passing through the middle of meshpatch.

Definition at line 145 of file SvgMeshPatch.cpp.

{
    std::array<QPointF, 4> p;
    std::array<QPointF, 4> curvedBoundary0;
    std::array<QPointF, 4> curvedBoundary1;
 
    QPointF midpointRuled0;
    QPointF midpointRuled1;
 
    if (isVertical) {
        curvedBoundary0 = getSegment(Right);
        curvedBoundary1 = getSegment(Left);
 
        midpointRuled0 = segmentPointAt(Top, 0.5);
        midpointRuled1 = segmentPointAt(Bottom, 0.5);
    } else {
        curvedBoundary0 = getSegment(Top);
        curvedBoundary1 = getSegment(Bottom);
 
        midpointRuled0 = segmentPointAt(Left, 0.5);
        midpointRuled1 = segmentPointAt(Right, 0.5);
    }
 
    // we have to reverse it, cB1 & cB2 are in opposite direction
    std::reverse(curvedBoundary1.begin(), curvedBoundary1.end());
 
    // Sum of two Bezier curve is a Bezier curve
    QVector<QPointF> midCurved = {
        (curvedBoundary0[0] + curvedBoundary1[0]) / 2,
        (curvedBoundary0[1] + curvedBoundary1[1]) / 2,
        (curvedBoundary0[2] + curvedBoundary1[2]) / 2,
        (curvedBoundary0[3] + curvedBoundary1[3]) / 2,
    };
 
    // line cutting the bilinear surface in middle
    QPointF x_2_1 = lerp(midpointRuled0, midpointRuled1, 1.0 / 3);
    QPointF x_2_2 = lerp(midpointRuled0, midpointRuled1, 2.0 / 3);
 
    // line cutting rulled surface in middle
    QPointF x_3_1 = lerp(midCurved[0], midCurved[3], 1.0 / 3);
    QPointF x_3_2 = lerp(midCurved[0], midCurved[3], 2.0 / 3);
 
 
    p[0] = midpointRuled0;
 
    // X_1 = x_1_1 + x_2_1 - x_3_1
    p[1] = midCurved[1] + x_2_1 - x_3_1;
 
    // X_2 = x_1_2 + x_2_2 - x_3_2
    p[2] = midCurved[2] + x_2_2 - x_3_2;
 
    p[3] = midpointRuled1;
 
    return p;
}

References Bottom, getSegment(), Left, lerp(), p, Right, segmentPointAt(), and Top.

getMidpointParametric()

QPointF SvgMeshPatch::getMidpointParametric ( Type type ) const

inline

returns the midPoint in parametric space

Definition at line 62 of file SvgMeshPatch.h.

                                                          {
        return (m_parametricCoords[type] + m_parametricCoords[(type + 1) % Size]) * 0.5;
    }

getPath()

QPainterPath SvgMeshPatch::getPath

(

)

const

Get full (closed) meshpath.

Definition at line 125 of file SvgMeshPatch.cpp.

{
    QPainterPath path;
    path.moveTo(controlPoints[Top][0]);
    for (const auto& i: controlPoints) {
        path.cubicTo(i[1], i[2], i[3]);
    }
    return path;
}

References controlPoints, and Top.

getSegment()

std::array< QPointF, 4 > SvgMeshPatch::getSegment

(

Type

type

)

const

Get a segment of the path in the meshpatch.

Definition at line 120 of file SvgMeshPatch.cpp.

{
    return controlPoints[type];
}

References controlPoints.

getStop()

SvgMeshStop SvgMeshPatch::getStop

(

SvgMeshPatch::Type

type

)

const

returns the starting point of the stop

Definition at line 103 of file SvgMeshPatch.cpp.

{
    return m_nodes[type];
}

References m_nodes.

isDivisibleHorizontally()

bool SvgMeshPatch::isDivisibleHorizontally

(

)

const

Definition at line 445 of file SvgMeshPatch.cpp.

{
    // I arrived at this number by the virtue called trial 'n error
    const qreal minlength = 1.7;
 
    // a decent average, thanks to Khronos's forums
    const qreal line1 = QLineF(controlPoints[Right][0], controlPoints[Right][3]).length();
    const qreal control1 = controlrectLen(getSegment(Right));
    if ((line1 + control1 / 2) < minlength) {
        return false;
    }
 
    const qreal line2 = QLineF(controlPoints[Left][0], controlPoints[Left][3]).length();
    const qreal control2 = controlrectLen(getSegment(Left));
    if ((line2 + control2 / 2) < minlength) {
        return false;
    }
 
    return true;
}

References controlPoints, controlrectLen(), getSegment(), Left, and Right.

isDivisibleVertically()

bool SvgMeshPatch::isDivisibleVertically

(

)

const

Definition at line 424 of file SvgMeshPatch.cpp.

{
    // I arrived at this number by the virtue called trial 'n error
    const qreal minlength = 1.7;
    const qreal line1 = QLineF(controlPoints[Top][0], controlPoints[Top][3]).length();
    const qreal control1 = controlrectLen(getSegment(Top));
 
    // a decent average, thanks to Khronos's forums
    if ((line1 + control1 / 2) < minlength) {
        return false;
    }
 
    const qreal line2 = QLineF(controlPoints[Bottom][0], controlPoints[Bottom][3]).length();
    const qreal control2 = controlrectLen(getSegment(Bottom));
    if ((line2 + control2 / 2) < minlength) {
        return false;
    }
 
    return true;
}

References Bottom, controlPoints, controlrectLen(), getSegment(), and Top.

lineTo()

void SvgMeshPatch::lineTo

(

const QPointF &

p

)

Helper to convert to a cubic curve internally.

Definition at line 83 of file SvgMeshPatch.cpp.

{
    controlPoints[counter][1] = lerp(controlPoints[counter][0], p, 1.0 / 3);
    controlPoints[counter][2] = lerp(controlPoints[counter][0], p, 2.0 / 3);
    controlPoints[counter][3] = p;
    counter++;
    if (counter < Size)
        controlPoints[counter][0] = p;
}

References controlPoints, counter, lerp(), p, and Size.

modifyCorner()

void SvgMeshPatch::modifyCorner	(	SvgMeshPatch::Type	type,
		const QPointF &	delta )

Definition at line 513 of file SvgMeshPatch.cpp.

{
    controlPoints[type][0] -= delta;
    controlPoints[type][1] -= delta;
    m_nodes[type].point = controlPoints[type][0];
 
    controlPoints[(Size + type - 1) % Size][3] -= delta;
    controlPoints[(Size + type - 1) % Size][2] -= delta;
}

References controlPoints, m_nodes, and Size.

modifyPath()

void SvgMeshPatch::modifyPath	(	SvgMeshPatch::Type	type,
		std::array< QPointF, 4 >	newPath )

Definition at line 507 of file SvgMeshPatch.cpp.

{
    controlPoints[type] = newPath;
    m_nodes[type].point = newPath[0];
}

References controlPoints, and m_nodes.

moveTo()

void SvgMeshPatch::moveTo

(

const QPointF &

p

)

Definition at line 78 of file SvgMeshPatch.cpp.

{
    controlPoints[counter][0] = p;
}

References controlPoints, counter, and p.

parseMeshPath()

QPointF SvgMeshPatch::parseMeshPath ( const QString & path, bool pathIncomplete = false, const QPointF lastPoint = QPointF() )

private

Definition at line 545 of file SvgMeshPatch.cpp.

{
    // bits and pieces from KoPathShapeLoader, see the copyright above
    if (!s.isEmpty()) {
        QString d = s;
        d.replace(',', ' ');
        d = d.simplified();
 
        const QByteArray buffer = d.toLatin1();
        const char *ptr = buffer.constData();
        qreal curx = m_startingPoint.x();
        qreal cury = m_startingPoint.y();
        qreal tox, toy, x1, y1, x2, y2;
        bool relative = false;
        char command = *(ptr++);
 
        if (m_newPath) {
            moveTo(m_startingPoint);
            m_newPath = false;
        }
 
       while (*ptr == ' ')
           ++ptr;
 
       switch (command) {
       case 'l':
           relative = true;
           Q_FALLTHROUGH();
       case 'L': {
           ptr = getCoord(ptr, tox);
           ptr = getCoord(ptr, toy);
 
           if (relative) {
               tox = curx + tox;
               toy = cury + toy;
           }
 
           if (pathIncomplete) {
               tox = lastPoint.x();
               toy = lastPoint.y();
           }
 
           // we convert lines to cubic curve
           lineTo({tox, toy});
           break;
       }
       case 'c':
           relative = true;
           Q_FALLTHROUGH();
       case 'C': {
           ptr = getCoord(ptr, x1);
           ptr = getCoord(ptr, y1);
           ptr = getCoord(ptr, x2);
           ptr = getCoord(ptr, y2);
           ptr = getCoord(ptr, tox);
           ptr = getCoord(ptr, toy);
 
           if (relative) {
               x1  = curx + x1;
               y1  = cury + y1;
               x2  = curx + x2;
               y2  = cury + y2;
               tox = curx + tox;
               toy = cury + toy;
           }
 
           if (pathIncomplete) {
               tox = lastPoint.x();
               toy = lastPoint.y();
           }
 
           curveTo(QPointF(x1, y1), QPointF(x2, y2), QPointF(tox, toy));
           break;
       }
 
       default: {
           qWarning() << "SvgMeshPatch::parseMeshPath: Bad command \"" << command << "\"";
           return QPointF();
       }
       }
       return {tox, toy};
    }
    return QPointF();
}

References curveTo(), getCoord(), lineTo(), m_newPath, m_startingPoint, and moveTo().

segmentPointAt()

QPointF SvgMeshPatch::segmentPointAt	(	Type	type,
		qreal	t ) const

get the point on a segment using De Casteljau's algorithm

Definition at line 108 of file SvgMeshPatch.cpp.

{
    QPointF p;
    deCasteljau(controlPoints[type], t, 0, 0, &p, 0, 0);
    return p;
}

References controlPoints, deCasteljau(), and p.

segmentSplitAt()

QPair< std::array< QPointF, 4 >, std::array< QPointF, 4 > > SvgMeshPatch::segmentSplitAt	(	Type	type,
		qreal	t ) const

split a segment using De Casteljau's algorithm

Definition at line 115 of file SvgMeshPatch.cpp.

{
    return splitAt(controlPoints[type], t);
}

References controlPoints, and splitAt().

setStopColor()

void SvgMeshPatch::setStopColor	(	SvgMeshPatch::Type	type,
		const QColor &	color )

Definition at line 523 of file SvgMeshPatch.cpp.

{
    m_nodes[type].color = color;
}

References m_nodes.

setTransform()

void SvgMeshPatch::setTransform

(

const QTransform &

matrix

)

Definition at line 528 of file SvgMeshPatch.cpp.

{
    m_startingPoint = matrix.map(m_startingPoint);
    for (int i = 0; i < Size; ++i) {
        m_nodes[i].point = matrix.map(m_nodes[i].point);
        for (int j = 0; j < 4; ++j) {
            controlPoints[i][j] = matrix.map(controlPoints[i][j]);
        }
    }
}

References controlPoints, m_nodes, m_startingPoint, and Size.

size()

QSizeF SvgMeshPatch::size

(

)

const

Get size swept by mesh in pts.

Definition at line 140 of file SvgMeshPatch.cpp.

{
    return boundingRect().size();
}

References boundingRect().

subdivide()

void SvgMeshPatch::subdivide	(	QVector< SvgMeshPatch * > &	subdivided,
		const QVector< QColor > &	colors ) const

Definition at line 295 of file SvgMeshPatch.cpp.

{
    KIS_ASSERT(colors.size() == 5);
 
    // The orientation is left to right and top to bottom, which means
    // Eg. the first part of splitTop is TopLeft and the second part is TopRight
    // Similarly the first part of splitRight is RightTop, but the first part of
    // splitLeft is splitLeft.second (once again, in Top to Bottom  convention)
    const QPair<std::array<QPointF, 4>, std::array<QPointF, 4>> splitTop    = segmentSplitAt(Top, 0.5);
    const QPair<std::array<QPointF, 4>, std::array<QPointF, 4>> splitRight  = segmentSplitAt(Right, 0.5);
    const QPair<std::array<QPointF, 4>, std::array<QPointF, 4>> splitBottom = segmentSplitAt(Bottom, 0.5);
    const QPair<std::array<QPointF, 4>, std::array<QPointF, 4>> splitLeft   = segmentSplitAt(Left, 0.5);
 
    // The way the curve and the colors at the corners are arranged before and after subdivision
    //
    //              midc12
    //       c1       +       c2
    //        +---------------+
    //        |       |       |
    //        |       | midVer|
    //        |       | <     |
    // midc41 +---------------+ midc23
    //        |  ^    |       |
    //        | midHor|       |
    //        |       |       |
    //        +---------------+
    //       c4       +       c3
    //              midc43
    //
    //             
    //  midHor --> left to right
    //  midVer --> top to bottom
 
 
    QPair<std::array<QPointF, 4>, std::array<QPointF, 4>> midHor = splitAt(getMidCurve(/*isVertical = */ false), 0.5);
    QPair<std::array<QPointF, 4>, std::array<QPointF, 4>> midVer = splitAt(getMidCurve(/*isVertical = */ true), 0.5);
 
    // middle curve is shared among the two, so we need both directions
    std::array<QPointF, 4> reversedMidHorFirst = midHor.first;
    std::reverse(reversedMidHorFirst.begin(), reversedMidHorFirst.end());
    std::array<QPointF, 4> reversedMidHorSecond = midHor.second;
    std::reverse(reversedMidHorSecond.begin(), reversedMidHorSecond.end());
 
    std::array<QPointF, 4> reversedMidVerFirst = midVer.first;
    std::reverse(reversedMidVerFirst.begin(), reversedMidVerFirst.end());
    std::array<QPointF, 4> reversedMidVerSecond = midVer.second;
    std::reverse(reversedMidVerSecond.begin(), reversedMidVerSecond.end());
 
    QColor c1 = getStop(Top).color;
    QColor c2 = getStop(Right).color;
    QColor c3 = getStop(Bottom).color;
    QColor c4 = getStop(Left).color;
    QColor midc12 = colors[0];
    QColor midc23 = colors[1];
    QColor midc34 = colors[2];
    QColor midc41 = colors[3];
    QColor center = colors[4];
 
    // mid points in parametric space
    QPointF midTopP     = getMidpointParametric(Top);
    QPointF midRightP   = getMidpointParametric(Right);
    QPointF midBottomP  = getMidpointParametric(Bottom);
    QPointF midLeftP    = getMidpointParametric(Left);
    QPointF centerP     = 0.5 * (midTopP + midBottomP);
 
    // patch 1: TopLeft/NorthWest
    SvgMeshPatch *patch = new SvgMeshPatch(splitTop.first[0]);
    patch->addStop(splitTop.first, c1, Top);
    patch->addStop(midVer.first, midc12, Right);
    patch->addStop(reversedMidHorFirst, center, Bottom);
    patch->addStop(splitLeft.second, midc41, Left);
    patch->m_parametricCoords = {
        m_parametricCoords[0],
        midTopP,
        centerP,
        midLeftP
    };
    subdivided.append(patch);
 
    // patch 2: TopRight/NorthRight
    patch = new SvgMeshPatch(splitTop.second[0]);
    patch->addStop(splitTop.second, midc12, Top);
    patch->addStop(splitRight.first, c2, Right);
    patch->addStop(reversedMidHorSecond, midc23, Bottom);
    patch->addStop(reversedMidVerFirst, center, Left);
    patch->m_parametricCoords = {
        midTopP,
        m_parametricCoords[1],
        midRightP,
        centerP
    };
    subdivided.append(patch);
 
    // patch 3: BottomLeft/SouthWest
    patch = new SvgMeshPatch(midHor.first[0]);
    patch->addStop(midHor.first, midc41, Top);
    patch->addStop(midVer.second, center, Right);
    patch->addStop(splitBottom.second, midc34, Bottom);
    patch->addStop(splitLeft.first, c4, Left);
    patch->m_parametricCoords = {
        midLeftP,
        centerP,
        midBottomP,
        m_parametricCoords[3]
    };
    subdivided.append(patch);
 
    // patch 4: BottomRight/SouthEast
    patch = new SvgMeshPatch(midHor.second[0]);
    patch->addStop(midHor.second, center, Top);
    patch->addStop(splitRight.second, midc23, Right);
    patch->addStop(splitBottom.first, c3, Bottom);
    patch->addStop(reversedMidVerSecond, midc34, Left);
    patch->m_parametricCoords = {
        centerP,
        midRightP,
        m_parametricCoords[2],
        midBottomP
    };
    subdivided.append(patch);
}

References addStop(), Bottom, SvgMeshStop::color, getMidCurve(), getMidpointParametric(), getStop(), KIS_ASSERT, Left, m_parametricCoords, Right, segmentSplitAt(), splitAt(), SvgMeshPatch(), and Top.

subdivideHorizontally()

void SvgMeshPatch::subdivideHorizontally	(	QVector< SvgMeshPatch * > &	subdivided,
		const QVector< QColor > &	colors ) const

Definition at line 201 of file SvgMeshPatch.cpp.

{
    const QPair<SvgMeshPath, SvgMeshPath> splitRight = segmentSplitAt(Right, 0.5);
    const QPair<SvgMeshPath, SvgMeshPath> splitLeft  = segmentSplitAt(Left, 0.5);
 
    SvgMeshPath midHor = getMidCurve(/*isVertical = */ false);
    SvgMeshPath rMidHor = midHor;
    std::reverse(rMidHor.begin(), rMidHor.end());
 
    QColor c1 = getStop(Top).color;
    QColor c2 = getStop(Right).color;
    QColor c3 = getStop(Bottom).color;
    QColor c4 = getStop(Left).color;
    QColor midc23 = colors[1];
    QColor midc41 = colors[3];
 
    QPointF midRightParametric = getMidpointParametric(Right);
    QPointF midLeftParametric = getMidpointParametric(Left);
 
    SvgMeshPatch *patch = new SvgMeshPatch(getSegment(Top)[0]);
    patch->addStop(getSegment(Top), c1, Top);
    patch->addStop(splitRight.first, c2, Right);
    patch->addStop(rMidHor, midc23, Bottom);
    patch->addStop(splitLeft.second, midc41, Left);
    patch->m_parametricCoords = {
        m_parametricCoords[0],
        m_parametricCoords[1],
        midRightParametric,
        midLeftParametric
    };
    subdivided.append(patch);
 
    patch = new SvgMeshPatch(midHor[0]);
    patch->addStop(midHor, midc41, Top);
    patch->addStop(splitRight.second, midc23, Right);
    patch->addStop(getSegment(Bottom), c3, Bottom);
    patch->addStop(splitLeft.first,c4, Left);
    patch->m_parametricCoords = {
        midLeftParametric,
        midRightParametric,
        m_parametricCoords[2],
        m_parametricCoords[3]
    };
    subdivided.append(patch);
}

References addStop(), Bottom, SvgMeshStop::color, getMidCurve(), getMidpointParametric(), getSegment(), getStop(), Left, m_parametricCoords, Right, segmentSplitAt(), SvgMeshPatch(), and Top.

subdivideVertically()

void SvgMeshPatch::subdivideVertically	(	QVector< SvgMeshPatch * > &	subdivided,
		const QVector< QColor > &	colors ) const

Definition at line 248 of file SvgMeshPatch.cpp.

{
    const QPair<SvgMeshPath, SvgMeshPath> splitTop    = segmentSplitAt(Top, 0.5);
    const QPair<SvgMeshPath, SvgMeshPath> splitBottom = segmentSplitAt(Bottom, 0.5);
 
    SvgMeshPath midVer = getMidCurve(/*isVertical = */ true);
    SvgMeshPath rMidVer = midVer;
    std::reverse(rMidVer.begin(), rMidVer.end());
 
    QColor c1 = getStop(Top).color;
    QColor c2 = getStop(Right).color;
    QColor c3 = getStop(Bottom).color;
    QColor c4 = getStop(Left).color;
    QColor midc12 = colors[0];
    QColor midc34 = colors[2];
 
    QPointF midTopParametric = getMidpointParametric(Top);
    QPointF midBottomParametric = getMidpointParametric(Bottom);
 
    SvgMeshPatch *patch = new SvgMeshPatch(splitTop.first[0]);
    patch->addStop(splitTop.first, c1, Top);
    patch->addStop(midVer, midc12, Right);
    patch->addStop(splitBottom.second, midc34, Bottom);
    patch->addStop(getSegment(Left), c4, Left);
    patch->m_parametricCoords = {
        m_parametricCoords[0],
        midTopParametric,
        midBottomParametric,
        m_parametricCoords[3]
    };
    subdivided.append(patch);
 
    patch = new SvgMeshPatch(splitTop.second[0]);
    patch->addStop(splitTop.second, midc12, Top);
    patch->addStop(getSegment(Right), c2, Right);
    patch->addStop(splitBottom.first, c3, Bottom);
    patch->addStop(rMidVer, midc34, Left);
    patch->m_parametricCoords = {
        midTopParametric,
        m_parametricCoords[1],
        m_parametricCoords[2],
        midBottomParametric
    };
    subdivided.append(patch);
}

References addStop(), Bottom, SvgMeshStop::color, getMidCurve(), getMidpointParametric(), getSegment(), getStop(), Left, m_parametricCoords, Right, segmentSplitAt(), SvgMeshPatch(), and Top.

Member Data Documentation

controlPoints

std::array<std::array<QPointF, 4>, 4> SvgMeshPatch::controlPoints

private

Definition at line 134 of file SvgMeshPatch.h.

counter

int SvgMeshPatch::counter {0}

private

Definition at line 128 of file SvgMeshPatch.h.

{0};

m_newPath

bool SvgMeshPatch::m_newPath

private

Definition at line 127 of file SvgMeshPatch.h.

m_nodes

std::array<SvgMeshStop, Size> SvgMeshPatch::m_nodes

private

Definition at line 133 of file SvgMeshPatch.h.

m_parametricCoords

std::array<QPointF, 4> SvgMeshPatch::m_parametricCoords

private

Coordinates in UV space.

Definition at line 136 of file SvgMeshPatch.h.

m_startingPoint

QPointF SvgMeshPatch::m_startingPoint

private

This is the starting point for each path.

Definition at line 131 of file SvgMeshPatch.h.

---

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

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