KisAlgebra2D::VectorPath Class Reference

#include <kis_algebra_2d.h>

Classes
struct	Segment
struct	VectorPathPoint

Public Member Functions
QPainterPath	asPainterPath () const
bool	fuzzyComparePointsCyclic (const VectorPath &path, qreal eps=0.0f) const
int	pathIndexToSegmentIndex (int index)
VectorPathPoint	pointAt (int i) const
int	pointsCount () const
VectorPath	reversed () const
QList< VectorPathPoint >	segmentAt (int i) const
QLineF	segmentAtAsLine (int i) const
std::optional< Segment >	segmentAtAsSegment (int i) const
int	segmentIndexToPathIndex (int index)
int	segmentsCount () const
VectorPath	trulySimplified (qreal epsDegrees=0.5) const
	VectorPath (const QList< VectorPathPoint > path)
	VectorPath (const QPainterPath &path)

Static Public Member Functions
static QList< QPointF >	intersectSegmentWithLineBounded (const QLineF &line, const Segment &segment)
static QList< QPointF >	intersectSegmentWithLineBounded (const QLineF &line, const VectorPathPoint &p1, const VectorPathPoint &p2)

Private Attributes
QPainterPath	m_originalPath
QList< VectorPathPoint >	m_points

Detailed Description

Definition at line 586 of file kis_algebra_2d.h.

Constructor & Destructor Documentation

VectorPath() [1/2]

KisAlgebra2D::VectorPath::VectorPath

(

const QPainterPath &

path

)

Definition at line 2050 of file kis_algebra_2d.cpp.

{
    using VPoint = VectorPath::VectorPathPoint;
 
    m_points = QList<VectorPath::VectorPathPoint>();
    for (int i = 0; i < path.elementCount(); i++) {
        QPainterPath::Element el = path.elementAt(i);
        switch(el.type) {
            case QPainterPath::MoveToElement:
                m_points.append(VPoint(VPoint::MoveTo, el));
            break;
            case QPainterPath::LineToElement:
                m_points.append(VPoint(VPoint::LineTo, el));
            break;
            case QPainterPath::CurveToDataElement:
            KIS_SAFE_ASSERT_RECOVER_BREAK(false);
            break;
            case QPainterPath::CurveToElement:
                KIS_SAFE_ASSERT_RECOVER(i + 2 < path.elementCount()) { continue; }
                KIS_SAFE_ASSERT_RECOVER(path.elementAt(i + 1).type == QPainterPath::CurveToDataElement) { continue; }
                KIS_SAFE_ASSERT_RECOVER(path.elementAt(i + 2).type == QPainterPath::CurveToDataElement) { continue; }
                // Qt saves the data this way: [control point 1, CurveToElement] [control point 2, CurveToDataElement] [end point, CurveToDataElement]
                m_points.append(VPoint(VPoint::BezierTo, path.elementAt(i + 2), el, path.elementAt(i + 1)));
                i += 2; // skip next two points
            break;
        }
    }
}

References KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_BREAK, and m_points.

VectorPath() [2/2]

KisAlgebra2D::VectorPath::VectorPath

(

const QList< VectorPathPoint >

path

)

Definition at line 2079 of file kis_algebra_2d.cpp.

{
    m_points = path;
}

References m_points.

Member Function Documentation

asPainterPath()

QPainterPath KisAlgebra2D::VectorPath::asPainterPath

(

)

const

Definition at line 2367 of file kis_algebra_2d.cpp.

{
    using VPoint = VectorPath::VectorPathPoint;
    if (m_originalPath.elementCount() > 0) {
        return m_originalPath;
    }
    QPainterPath response;
    for (int i = 0; i < pointsCount(); i++) {
        switch(m_points[i].type) {
        case VPoint::MoveTo:
            response.moveTo(m_points[i].endPoint);
            break;
        case VPoint::LineTo:
            response.lineTo(m_points[i].endPoint);
            break;
        case VPoint::BezierTo:
            response.cubicTo(m_points[i].controlPoint1, m_points[i].controlPoint2, m_points[i].endPoint);
            break;
        }
    }
    response.closeSubpath();
    return response;
}

References KisAlgebra2D::VectorPath::VectorPathPoint::lineTo(), m_originalPath, m_points, KisAlgebra2D::VectorPath::VectorPathPoint::moveTo(), and pointsCount().

fuzzyComparePointsCyclic()

bool KisAlgebra2D::VectorPath::fuzzyComparePointsCyclic	(	const VectorPath &	path,
		qreal	eps = 0.0f ) const

Definition at line 2313 of file kis_algebra_2d.cpp.

{
    using VPoint = VectorPath::VectorPathPoint;
 
    if (segmentsCount() != path.segmentsCount()) {
        return false;
    }
 
    bool fuzzy = qFuzzyIsNull(eps);
 
    auto comparePoints = [fuzzy, eps] (QPointF left, QPointF right) {
        if (fuzzy) {
            return fuzzyPointCompare(left, right);
        } else {
            return fuzzyPointCompare(left, right, eps);
        }
    };
 
 
    VPoint leftStart = path.pointAt(0);
    QList<int> rightStartingPoints;
    for (int i = 0; i < path.pointsCount(); i++) {
        if (comparePoints(leftStart.endPoint, path.pointAt(i).endPoint)) {
            rightStartingPoints << i;
        }
    }
 
    Q_FOREACH(int startId, rightStartingPoints) {
        bool isEqual = true;
        for (int i = 0; i < pointsCount(); i++) {
            int rightId = wrapValue(i + startId, 0, pointsCount());
            if (!comparePoints(pointAt(i).endPoint, path.pointAt(rightId).endPoint)) {
                isEqual = false;
                break;
            }
        }
        if (isEqual) {
            return true;
        }
        for (int i = 0; i < pointsCount(); i++) {
            int rightId = wrapValue(startId - i, 0, pointsCount());
            if (!comparePoints(pointAt(i).endPoint, path.pointAt(rightId).endPoint)) {
                isEqual = false;
                break;
            }
        }
        if (isEqual) {
            return true;
        }
    }
 
    return false;
}

References KisAlgebra2D::VectorPath::VectorPathPoint::endPoint, eps, KisAlgebra2D::fuzzyPointCompare(), pointAt(), pointsCount(), qFuzzyIsNull(), segmentsCount(), and KisAlgebra2D::wrapValue().

intersectSegmentWithLineBounded() [1/2]

QList< QPointF > KisAlgebra2D::VectorPath::intersectSegmentWithLineBounded ( const QLineF & line, const Segment & segment )

static

Definition at line 2127 of file kis_algebra_2d.cpp.

{
    qreal eps = 1e-5;
    if (segment.type != VectorPath::VectorPathPoint::BezierTo) {
        QLineF segLine = QLineF(segment.startPoint, segment.endPoint);
        QPointF intersection;
        if (segLine.intersects(line, &intersection) == QLineF::BoundedIntersection) {
            return QList<QPointF> {intersection};
        } else {
            return QList<QPointF>();
        }
 
    } else {
        QList<QPointF> result;
        // check for intersections
        QVector<qreal> intersections = KisBezierUtils::intersectWithLine(segment.startPoint, segment.controlPoint1, segment.controlPoint2, segment.endPoint, line, eps);
        for (int i = 0; i < intersections.count(); i++) {
            QPointF p = KisBezierUtils::bezierCurve(segment.startPoint, segment.controlPoint1, segment.controlPoint2, segment.endPoint, intersections[i]);
            bool onLine = isOnLine(line, p, eps, true, true, true);
            if (onLine) {
                result << p;
            }
        }
 
        return result;
    }
 
}

References KisBezierUtils::bezierCurve(), KisAlgebra2D::VectorPath::VectorPathPoint::BezierTo, KisAlgebra2D::VectorPath::Segment::controlPoint1, KisAlgebra2D::VectorPath::Segment::controlPoint2, KisAlgebra2D::VectorPath::Segment::endPoint, eps, KisBezierUtils::intersectWithLine(), KisAlgebra2D::isOnLine(), p, KisAlgebra2D::VectorPath::Segment::startPoint, and KisAlgebra2D::VectorPath::Segment::type.

intersectSegmentWithLineBounded() [2/2]

QList< QPointF > KisAlgebra2D::VectorPath::intersectSegmentWithLineBounded ( const QLineF & line, const VectorPathPoint & p1, const VectorPathPoint & p2 )

static

Definition at line 2156 of file kis_algebra_2d.cpp.

{
    return intersectSegmentWithLineBounded(line, VectorPath::Segment(p1, p2));
}

References intersectSegmentWithLineBounded(), p1, and p2.

pathIndexToSegmentIndex()

int KisAlgebra2D::VectorPath::pathIndexToSegmentIndex

(

int

index

)

Definition at line 2161 of file kis_algebra_2d.cpp.

{
    // first should be MoveTo
    int pathIndex = 0;
    for (int i = 1; i < m_points.length(); i++) {
        if (index < pathIndex) {
            // it was the previous segment, it's just a control point
            return i - 1;
        }
        if (index == pathIndex) {
            return i - 1;
        }
        if (m_points[i].type == VectorPathPoint::BezierTo) {
            pathIndex += 2; // add space for control points
        }
        pathIndex++;
    }
    return m_points.length() - 1;
}

References KisAlgebra2D::VectorPath::VectorPathPoint::BezierTo, and m_points.

pointAt()

VectorPath::VectorPathPoint KisAlgebra2D::VectorPath::pointAt

(

int

i

)

const

Definition at line 2089 of file kis_algebra_2d.cpp.

{
    return m_points[i];
}

References m_points.

pointsCount()

int KisAlgebra2D::VectorPath::pointsCount

(

)

const

Definition at line 2084 of file kis_algebra_2d.cpp.

{
    return m_points.length();
}

References m_points.

reversed()

VectorPath KisAlgebra2D::VectorPath::reversed

(

)

const

Definition at line 2299 of file kis_algebra_2d.cpp.

{
    using VPoint = VectorPath::VectorPathPoint;
    QList<VPoint> response;
    response.append(VPoint(VPoint::MoveTo, m_points[m_points.length() - 1].endPoint));
    for (int i = m_points.length() - 1; i > 0; i--) {
         // to reverse a segment, we take the end VPoint and change the .endPoint to the start VPoint coords
        VPoint point = m_points[i];
        point.endPoint = m_points[i - 1].endPoint;
        response.append(point);
    }
    return VectorPath(response);
}

References m_points, and VectorPath().

segmentAt()

QList< VectorPath::VectorPathPoint > KisAlgebra2D::VectorPath::segmentAt

(

int

i

)

const

Definition at line 2099 of file kis_algebra_2d.cpp.

{
    QList<VectorPath::VectorPathPoint> response;
    if (i < 0 || i >= segmentsCount()) {
        return response;
    }
    response << m_points[i] << m_points[i + 1];
    return response;
}

References m_points, and segmentsCount().

segmentAtAsLine()

QLineF KisAlgebra2D::VectorPath::segmentAtAsLine

(

int

i

)

const

Definition at line 2118 of file kis_algebra_2d.cpp.

{
    QList<VectorPath::VectorPathPoint> points = segmentAt(i);
    if (points.length() < 1) {
        return QLineF();
    }
    return QLineF(points[0].endPoint, points[1].endPoint);
}

References segmentAt().

segmentAtAsSegment()

std::optional< VectorPath::Segment > KisAlgebra2D::VectorPath::segmentAtAsSegment

(

int

i

)

const

Definition at line 2109 of file kis_algebra_2d.cpp.

{
    QList<VectorPath::VectorPathPoint> segment = segmentAt(i);
    if (segment.count() == 2) {
        return VectorPath::Segment(segment[0], segment[1]);
    }
    return std::nullopt;
}

References segmentAt().

segmentIndexToPathIndex()

int KisAlgebra2D::VectorPath::segmentIndexToPathIndex

(

int

index

)

Definition at line 2181 of file kis_algebra_2d.cpp.

{
    // first should be MoveTo
    int pathIndex = 0;
    for (int i = 1; i < m_points.length(); i++) {
        if (i - 1 == index) {
            if (m_points[i - 1].type == VectorPathPoint::BezierTo) {
                return pathIndex - 2;
            }
            return pathIndex;
        }
        if (m_points[i].type == VectorPathPoint::BezierTo) {
            pathIndex += 2; // add space for control points
        }
        pathIndex++;
    }
    if (m_points.length() > 0 && m_points[m_points.length() - 1].type == VectorPathPoint::BezierTo) {
        return pathIndex - 2;
    }
    return pathIndex;
}

References KisAlgebra2D::VectorPath::VectorPathPoint::BezierTo, and m_points.

segmentsCount()

int KisAlgebra2D::VectorPath::segmentsCount

(

)

const

Definition at line 2094 of file kis_algebra_2d.cpp.

{
    return m_points.length() - 1 >= 0 ? m_points.length() - 1 : 0;
}

References m_points.

trulySimplified()

VectorPath KisAlgebra2D::VectorPath::trulySimplified

(

qreal

epsDegrees = 0.5

)

const

Definition at line 2203 of file kis_algebra_2d.cpp.

{
    qreal eps = kisDegreesToRadians(epsDegrees);
 
 
    using VPoint = VectorPath::VectorPathPoint;
 
    if (m_points.length() < 1) {
        return VectorPath(QList<VectorPath::VectorPathPoint>());
    }
 
    QList<VPoint> response;
    VPoint lineBeginPoint = VPoint(VPoint::MoveTo, QPointF(0, 0));
    VPoint previousPoint = m_points[0];
 
 
    //qreal eps = 1e-05;
    auto onTheLine = [eps] (QPointF start, QPointF middle, QPointF end) {
        QLineF line1(start, end);
        QLineF line2(start, middle);
 
        return (qAbs(crossProduct(end - start, middle - start)/line1.length()/line2.length()) < eps);
    };
 
    for (int i = 1; i < m_points.length(); i++) {
        if (m_points[i].type == VPoint::MoveTo) {
            if (previousPoint.type == VPoint::MoveTo) {
                previousPoint = m_points[i]; // let's skip the previous point since they're both just moving
                continue;
            } else { // LineTo or BezierTo, both need to be added
                response << previousPoint;
                previousPoint = m_points[i];
                continue;
            }
        } else if (m_points[i].type == VPoint::LineTo) {
            if (previousPoint.type == VPoint::LineTo) {
                // check whether they're parallel
                if (!onTheLine(lineBeginPoint.endPoint, previousPoint.endPoint, m_points[i].endPoint)) {
                    response << previousPoint;
                    lineBeginPoint = previousPoint;
                }
                previousPoint = m_points[i]; // let's skip the previous point since they're parallel
                continue;
            } else { // MoveTo or BezierTo, both need to be added
                response << previousPoint;
                lineBeginPoint = previousPoint;
                previousPoint = m_points[i];
                continue;
            }
        } else { // currently in BezierTo
            response << previousPoint;
            previousPoint = m_points[i];
            continue;
        }
    }
    response << previousPoint;
 
    // now eliminate additional point at the beginning of the shape if it's in the middle of a line
    // and wasn't simplified only because it's at the beginning
 
    if (response.length() < 3) {
        return VectorPath(response);
    }
 
    VPoint start = response[0];
    VPoint second = response[1];
 
    if (start.type == VPoint::MoveTo) {
        if (fuzzyPointCompare(previousPoint.endPoint, start.endPoint)) {
            // they are the same point, now whether they're on the line
            if (second.type == VPoint::LineTo && onTheLine(response[response.length()-2].endPoint, start.endPoint, second.endPoint)) {
                response.pop_front();
                response[0].type = VPoint::MoveTo;
                response[response.length() - 1].endPoint = second.endPoint;
            }
        }
 
    } else if (response[0].type == VPoint::LineTo) { // first point is then QPointF(0, 0)
        if (qFuzzyIsNull(previousPoint.endPoint.x()) && qFuzzyIsNull(previousPoint.endPoint.y())) {
            // they are the same point, now whether they're on the line
            if (second.type == VPoint::LineTo && onTheLine(previousPoint.endPoint, QPointF(0, 0), start.endPoint)) {
                // note: leaving this debug for future reference
                qCritical() << "We're in this case";
                //response.pop_front();
                //response[0].type = VPoint::MoveTo;
                //response[response.length() - 1].endPoint = start.endPoint;
            }
        }
    }
 
 
 
 
    return VectorPath(response);
}

References KisAlgebra2D::crossProduct(), eps, KisAlgebra2D::fuzzyPointCompare(), kisDegreesToRadians(), m_points, qFuzzyIsNull(), and VectorPath().

Member Data Documentation

m_originalPath

QPainterPath KisAlgebra2D::VectorPath::m_originalPath

private

Definition at line 687 of file kis_algebra_2d.h.

m_points

QList<VectorPathPoint> KisAlgebra2D::VectorPath::m_points

private

Definition at line 688 of file kis_algebra_2d.h.

---

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

• libs/global/kis_algebra_2d.h
• libs/global/kis_algebra_2d.cpp