KisBezierUtils Namespace Reference

Classes
class	BezierSegment
struct	Range

Functions
QPointF	bezierCurve (const QList< QPointF > &points, qreal t)
QPointF	bezierCurve (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal t)
QPointF	bezierCurveDeriv (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal t)
QPointF	bezierCurveDeriv2 (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal t)
int	bezierDegree (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3)
template<typename Func >
std::pair< Range, Range >	calcTightSrcRectRangeInParamSpace1D (const Range &searchParamRange, const Range &searchSrcRange, const Range &rect, Func func, qreal srcPrecision, std::optional< Range > squeezeRange=std::nullopt)
QPointF	calculateGlobalPos (const std::array< QPointF, 12 > &points, const QPointF &localPoint)
	calculates global coordinate corresponding to the patch coordinate (u, v)
template<class PatchMethod >
QPointF	calculateGlobalPosImpl (const std::array< QPointF, 12 > &points, const QPointF &localPoint)
QPointF	calculateGlobalPosSVG2 (const std::array< QPointF, 12 > &points, const QPointF &localPoint)
	calculates global coordinate corresponding to the patch coordinate (u, v)
QPointF	calculateLocalPos (const std::array< QPointF, 12 > &points, const QPointF &globalPoint)
	calculates local (u,v) coordinates of the patch corresponding to globalPoint
template<class PatchMethod >
QPointF	calculateLocalPosImpl (const std::array< QPointF, 12 > &points, const QPointF &globalPoint)
QPointF	calculateLocalPosSVG2 (const std::array< QPointF, 12 > &points, const QPointF &globalPoint)
	calculates local (u,v) coordinates of the patch corresponding to globalPoint
int	controlPolygonZeros (const QList< QPointF > &controlPoints)
qreal	curveLength (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, const qreal error)
qreal	curveLengthAtPoint (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal t, const qreal error)
qreal	curveParamByProportion (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal proportion, const qreal error)
qreal	curveParamBySegmentLength (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal expectedLength, qreal totalLength, const qreal error)
qreal	curveProportionByParam (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal t, const qreal error)
void	deCasteljau (const QPointF &q0, const QPointF &q1, const QPointF &q2, const QPointF &q3, qreal t, QPointF *p0, QPointF *p1, QPointF *p2, QPointF *p3, QPointF *p4)
QPointF	interpolateQuadric (const QPointF &p0, const QPointF &p2, const QPointF &pt, qreal t)
	Interpolates quadric curve passing through given points.
QVector< qreal >	intersectWithLine (const QPointF &p0, const QPointF &p1, const QPointF &p2, const QPointF &p3, const QLineF &line, qreal eps)
QVector< qreal >	intersectWithLineImpl (const QPointF &p0, const QPointF &p1, const QPointF &p2, const QPointF &p3, const QLineF &line, qreal eps, qreal alpha, qreal beta)
boost::optional< qreal >	intersectWithLineNearest (const QPointF &p0, const QPointF &p1, const QPointF &p2, const QPointF &p3, const QLineF &line, const QPointF &nearestAnchor, qreal eps)
bool	isLinearSegmentByControlPoints (const QPointF &p0, const QPointF &p1, const QPointF &p2, const QPointF &p3, const qreal eps=1e-4)
bool	isLinearSegmentByDerivatives (const QPointF &p0, const QPointF &d0, const QPointF &p1, const QPointF &d1, const qreal eps=1e-4)
QVector< qreal >	linearizeCurve (const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, const qreal eps)
QVector< qreal >	mergeLinearizationSteps (const QVector< qreal > &a, const QVector< qreal > &b)
qreal	nearestPoint (const QList< QPointF > controlPoints, const QPointF &point, qreal *resultDistance, QPointF *resultPoint)
std::pair< QPointF, QPointF >	offsetSegment (qreal t, const QPointF &offset)
	moves point t of the curve by offset offset
QDebug	operator<< (QDebug dbg, const Range &r)
std::pair< QPointF, QPointF >	removeBezierNode (const QPointF &p0, const QPointF &p1, const QPointF &p2, const QPointF &p3, const QPointF &q1, const QPointF &q2, const QPointF &q3)
	Adjusts position for the bezier control points after removing a node.

Function Documentation

bezierCurve() [1/2]

QPointF KisBezierUtils::bezierCurve ( const QList< QPointF > & points, qreal t )

inline

Definition at line 113 of file KisBezierUtils.h.

{
    QPointF result;
 
    if (points.size() == 2) {
        result = lerp(points.first(), points.last(), t);
    } else if (points.size() == 3) {
        result = bezierCurve(points[0], points[1], points[1], points[2], t);
    } else if (points.size() == 4) {
        result = bezierCurve(points[0], points[1], points[2], points[3], t);
    } else {
        KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "Unsupported number of bezier control points");
    }
 
    return result;
}

References bezierCurve(), KIS_SAFE_ASSERT_RECOVER_NOOP, and lerp().

bezierCurve() [2/2]

QPointF KisBezierUtils::bezierCurve ( const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal t )

inline

Definition at line 88 of file KisBezierUtils.h.

{
#if 0
    const qreal t_2 = pow2(t);
    const qreal t_3 = t_2 * t;
    const qreal t_inv = 1.0 - t;
    const qreal t_inv_2 = pow2(t_inv);
    const qreal t_inv_3 = t_inv_2 * t_inv;
 
    return
        t_inv_3 * p0 +
        3 * t_inv_2 * t * p1 +
        3 * t_inv * t_2 * p2 +
        t_3 * p3;
#else
    QPointF q0, q1, q2, q3, q4;
    deCasteljau(p0, p1, p2, p3, t, &q0, &q1, &q2, &q3, &q4);
    return q2;
#endif
}

References deCasteljau(), p0, p1, p2, p3, pow2(), q0, q1, q2, and q3.

bezierCurveDeriv()

QPointF KisBezierUtils::bezierCurveDeriv ( const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal t )

inline

Definition at line 22 of file KisBezierUtils.h.

{
    const qreal t_2 = pow2(t);
    const qreal t_inv = 1.0 - t;
    const qreal t_inv_2 = pow2(t_inv);
 
    return
        3 * t_inv_2 * (p1 - p0) +
        6 * t_inv * t * (p2 - p1) +
        3 * t_2 * (p3 - p2);
}

References p0, p1, p2, p3, and pow2().

bezierCurveDeriv2()

QPointF KisBezierUtils::bezierCurveDeriv2 ( const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3, qreal t )

inline

Definition at line 38 of file KisBezierUtils.h.

{
    const qreal t_inv = 1.0 - t;
 
    return
        6 * t_inv * (p2 - 2 * p1 + p0) +
        6 * t * (p3 - 2 * p2 + p1);
}

References p0, p1, p2, and p3.

bezierDegree()

int KisBezierUtils::bezierDegree ( const QPointF p0, const QPointF p1, const QPointF p2, const QPointF p3 )

inline

Definition at line 158 of file KisBezierUtils.h.

{
    const qreal eps = 1e-4;
 
    int degree = 3;
 
    if (isLinearSegmentByControlPoints(p0, p1, p2, p3, eps)) {
        degree = 1;
    } else if (KisAlgebra2D::fuzzyPointCompare(p1, p2, eps)) {
        degree = 2;
    }
 
    return degree;
}

References eps, KisAlgebra2D::fuzzyPointCompare(), isLinearSegmentByControlPoints(), p0, p1, p2, and p3.

calcTightSrcRectRangeInParamSpace1D()

template<typename Func >

std::pair< Range, Range > KisBezierUtils::calcTightSrcRectRangeInParamSpace1D	(	const Range &	searchParamRange,
		const Range &	searchSrcRange,
		const Range &	rect,
		Func	func,
		qreal	srcPrecision,
		std::optional< Range >	squeezeRange = std::nullopt )

Approximate the rect in param-space of the bezier patch that fully covers passed rect in the source-space. Due to the nature of the patch mapping, the result cannot be calculated precisely (easily). The passed srcPresition is only meant to be used for approximation algorithm termination. There is no guarantee that the result covers rect with this precision.

The function uses a simple binary search approach to estimate the borders of the rectangle in question.

To get better precision use iterational approach by combining X- and Y-axis approximation using searchParamRange and squeezeRange.

Parameters

searchParamRange	the range in param-space where the passed rect is searched for. The rect must be guaranteed to be present in this range, otherwise the behavior is undeifned. When doing iterational precision search, pass externalRange from the previous pass here.
searchSrcRange	the range in source-space, where the rect is placed. It is only used to check is the rect is placed exactly at the border of that range.
rect	rect in source-space that is searched for
func	the functor that maps a param in the param-space into a range in the source space
srcPrecision	src-space precision at which the search is stopped
squeezeRange	when doing iterational search, pass the opposite-axis range of the rectangle

Returns

a pair of {externalRange, internalRange} which "covers" and "is covered" by the rectangle correspondingly

Definition at line 135 of file KisBezierPatchParamSpaceUtils.h.

{
    Range leftSideParamRange = searchParamRange;
    Range rightSideParamRange = searchParamRange;
 
    if (qFuzzyCompare(rect.start, searchSrcRange.start)) {
        leftSideParamRange = {searchParamRange.start, searchParamRange.start};
    } else {
        // search left side
        while (1) {
            KIS_SAFE_ASSERT_RECOVER_BREAK(!leftSideParamRange.isEmpty());
 
            qreal currentSplitParam = leftSideParamRange.mid();
            Range currentSplitSrcRange = func(currentSplitParam);
            if (squeezeRange) {
                currentSplitSrcRange.squeezeRange(*squeezeRange);
            }
 
            std::optional<qreal> forwardDistance = currentSplitSrcRange.forwardDistanceTo(rect);
 
            if (!forwardDistance || qFuzzyIsNull(*forwardDistance)) {
                leftSideParamRange.end = currentSplitParam;
                rightSideParamRange.start = std::max(currentSplitParam, rightSideParamRange.start);
            } else if (*forwardDistance > 0) {
                KIS_SAFE_ASSERT_RECOVER_NOOP(currentSplitParam >= leftSideParamRange.start);
                leftSideParamRange.start = currentSplitParam;
                rightSideParamRange.start = std::max(currentSplitParam, rightSideParamRange.start);
            } else if (*forwardDistance < 0) {
                KIS_SAFE_ASSERT_RECOVER_NOOP(currentSplitParam <= rightSideParamRange.end);
                rightSideParamRange.end = currentSplitParam;
                leftSideParamRange.end = currentSplitParam;
            }
 
            if (forwardDistance && std::abs(*forwardDistance) < srcPrecision) {
                break;
            }
        }
    }
 
    if (qFuzzyCompare(rect.end, searchSrcRange.end)) {
        rightSideParamRange = {searchParamRange.end, searchParamRange.end};
    } else {
        // search right side
        while (1) {
            KIS_SAFE_ASSERT_RECOVER_BREAK(!rightSideParamRange.isEmpty());
 
            qreal currentSplitParam = rightSideParamRange.mid();
            Range currentSplitSrcRange = func(currentSplitParam);
 
            if (squeezeRange) {
                currentSplitSrcRange.squeezeRange(*squeezeRange);
            }
 
            std::optional<qreal> forwardDistance = currentSplitSrcRange.forwardDistanceTo(rect);
 
            if (!forwardDistance || qFuzzyIsNull(*forwardDistance)) {
                rightSideParamRange.start = currentSplitParam;
            } else if (*forwardDistance > 0) {
                rightSideParamRange.start = currentSplitParam;
            } else if (*forwardDistance < 0) {
                rightSideParamRange.end = currentSplitParam;
            }
 
            if (forwardDistance && std::abs(*forwardDistance) < srcPrecision) {
                break;
            }
        }
    }
 
    return std::make_pair(Range{leftSideParamRange.start, rightSideParamRange.end},
                          Range{leftSideParamRange.end, rightSideParamRange.start});
}

References KisBezierUtils::Range::end, KisBezierUtils::Range::forwardDistanceTo(), KisBezierUtils::Range::isEmpty(), KIS_SAFE_ASSERT_RECOVER_BREAK, KIS_SAFE_ASSERT_RECOVER_NOOP, KisBezierUtils::Range::mid(), qFuzzyCompare(), qFuzzyIsNull(), KisBezierUtils::Range::squeezeRange(), and KisBezierUtils::Range::start.

calculateGlobalPos()

KRITAGLOBAL_EXPORT QPointF KisBezierUtils::calculateGlobalPos	(	const std::array< QPointF, 12 > &	points,
		const QPointF &	localPoint )

calculates global coordinate corresponding to the patch coordinate (u, v)

The function uses Krita's own level-based patch interpolation algorithm

Parameters

points	control points as laid out in KisBezierPatch
localPoint	point in local coordinates

Returns

point in global coordinates

Definition at line 915 of file KisBezierUtils.cpp.

{
    return calculateGlobalPosImpl<LevelBasedPatchMethod>(points, localPoint);
}

calculateGlobalPosImpl()

template<class PatchMethod >

QPointF KisBezierUtils::calculateGlobalPosImpl	(	const std::array< QPointF, 12 > &	points,
		const QPointF &	localPoint )

Definition at line 882 of file KisBezierUtils.cpp.

{
    Params2D p;
 
    p.p0 = points[KisBezierPatch::TL];
    p.p1 = points[KisBezierPatch::TL_HC];
    p.p2 = points[KisBezierPatch::TR_HC];
    p.p3 = points[KisBezierPatch::TR];
 
    p.q0 = points[KisBezierPatch::BL];
    p.q1 = points[KisBezierPatch::BL_HC];
    p.q2 = points[KisBezierPatch::BR_HC];
    p.q3 = points[KisBezierPatch::BR];
 
    p.r0 = points[KisBezierPatch::TL];
    p.r1 = points[KisBezierPatch::TL_VC];
    p.r2 = points[KisBezierPatch::BL_VC];
    p.r3 = points[KisBezierPatch::BL];
 
    p.s0 = points[KisBezierPatch::TR];
    p.s1 = points[KisBezierPatch::TR_VC];
    p.s2 = points[KisBezierPatch::BR_VC];
    p.s3 = points[KisBezierPatch::BR];
 
    PatchMethod f(localPoint.x(), localPoint.y(), p);
    return f.value();
}

References KisBezierPatch::BL, KisBezierPatch::BL_HC, KisBezierPatch::BL_VC, KisBezierPatch::BR, KisBezierPatch::BR_HC, KisBezierPatch::BR_VC, p, KisBezierPatch::TL, KisBezierPatch::TL_HC, KisBezierPatch::TL_VC, KisBezierPatch::TR, KisBezierPatch::TR_HC, and KisBezierPatch::TR_VC.

calculateGlobalPosSVG2()

KRITAGLOBAL_EXPORT QPointF KisBezierUtils::calculateGlobalPosSVG2	(	const std::array< QPointF, 12 > &	points,
		const QPointF &	localPoint )

calculates global coordinate corresponding to the patch coordinate (u, v)

The function uses SVG2 toon patches algorithm

Parameters

points	control points as laid out in KisBezierPatch
localPoint	point in local coordinates

Returns

point in global coordinates

Definition at line 925 of file KisBezierUtils.cpp.

{
    return calculateGlobalPosImpl<SvgPatchMethod>(points, localPoint);
}

calculateLocalPos()

KRITAGLOBAL_EXPORT QPointF KisBezierUtils::calculateLocalPos	(	const std::array< QPointF, 12 > &	points,
		const QPointF &	globalPoint )

calculates local (u,v) coordinates of the patch corresponding to globalPoint

The function uses Krita's own level-based patch interpolation algorithm

Parameters

points	control points as laid out in KisBezierPatch
globalPoint	point in global coordinates

Returns

point in local coordinates

Definition at line 910 of file KisBezierUtils.cpp.

{
   return calculateLocalPosImpl<LevelBasedPatchMethod>(points, globalPoint);
}

calculateLocalPosImpl()

template<class PatchMethod >

QPointF KisBezierUtils::calculateLocalPosImpl	(	const std::array< QPointF, 12 > &	points,
		const QPointF &	globalPoint )

Definition at line 780 of file KisBezierUtils.cpp.

{
    QRectF patchBounds;
 
    for (auto it = points.begin(); it != points.end(); ++it) {
        KisAlgebra2D::accumulateBounds(*it, &patchBounds);
    }
 
    const QPointF approxStart = KisAlgebra2D::absoluteToRelative(globalPoint, patchBounds);
    KIS_SAFE_ASSERT_RECOVER_NOOP(QRectF(0,0,1.0,1.0).contains(approxStart));
 
#ifdef HAVE_GSL
    const gsl_multimin_fdfminimizer_type *T =
        gsl_multimin_fdfminimizer_vector_bfgs2;
    gsl_multimin_fdfminimizer *s = 0;
    gsl_vector *x;
    gsl_multimin_function_fdf minex_func;
 
    size_t iter = 0;
    int status;
 
    /* Starting point */
    x = gsl_vector_alloc (2);
    gsl_vector_set (x, 0, approxStart.x());
    gsl_vector_set (x, 1, approxStart.y());
 
    Params2D p;
 
    p.p0 = points[KisBezierPatch::TL];
    p.p1 = points[KisBezierPatch::TL_HC];
    p.p2 = points[KisBezierPatch::TR_HC];
    p.p3 = points[KisBezierPatch::TR];
 
    p.q0 = points[KisBezierPatch::BL];
    p.q1 = points[KisBezierPatch::BL_HC];
    p.q2 = points[KisBezierPatch::BR_HC];
    p.q3 = points[KisBezierPatch::BR];
 
    p.r0 = points[KisBezierPatch::TL];
    p.r1 = points[KisBezierPatch::TL_VC];
    p.r2 = points[KisBezierPatch::BL_VC];
    p.r3 = points[KisBezierPatch::BL];
 
    p.s0 = points[KisBezierPatch::TR];
    p.s1 = points[KisBezierPatch::TR_VC];
    p.s2 = points[KisBezierPatch::BR_VC];
    p.s3 = points[KisBezierPatch::BR];
 
    p.dstPoint = globalPoint;
 
    /* Initialize method and iterate */
    minex_func.n = 2;
    minex_func.f = my_f<PatchMethod>;
    minex_func.params = (void*)&p;
    minex_func.df = my_df<PatchMethod>;
    minex_func.fdf = my_fdf<PatchMethod>;
 
    s = gsl_multimin_fdfminimizer_alloc (T, 2);
    gsl_multimin_fdfminimizer_set (s, &minex_func, x, 0.01, 0.1);
 
    QPointF result;
 
 
    result.rx() = gsl_vector_get (s->x, 0);
    result.ry() = gsl_vector_get (s->x, 1);
 
    do
    {
        iter++;
        status = gsl_multimin_fdfminimizer_iterate(s);
 
        if (status)
            break;
 
        status = gsl_multimin_test_gradient (s->gradient, 1e-4);
 
        result.rx() = gsl_vector_get (s->x, 0);
        result.ry() = gsl_vector_get (s->x, 1);
 
        if (status == GSL_SUCCESS)
        {
            result.rx() = gsl_vector_get (s->x, 0);
            result.ry() = gsl_vector_get (s->x, 1);
            //qDebug() << "******* Converged to minimum" << ppVar(result);
 
        }
    }
    while (status == GSL_CONTINUE && iter < 10000);
 
//    ENTER_FUNCTION()<< ppVar(iter) << ppVar(globalPoint) << ppVar(result);
//    ENTER_FUNCTION() << ppVar(meshForwardMapping(result.x(), result.y(), p));
 
    gsl_vector_free(x);
    gsl_multimin_fdfminimizer_free (s);
 
    return result;
#else
    return approxStart;
#endif
}

References KisAlgebra2D::absoluteToRelative(), KisAlgebra2D::accumulateBounds(), KisBezierPatch::BL, KisBezierPatch::BL_HC, KisBezierPatch::BL_VC, KisBezierPatch::BR, KisBezierPatch::BR_HC, KisBezierPatch::BR_VC, KIS_SAFE_ASSERT_RECOVER_NOOP, p, KisBezierPatch::TL, KisBezierPatch::TL_HC, KisBezierPatch::TL_VC, KisBezierPatch::TR, KisBezierPatch::TR_HC, and KisBezierPatch::TR_VC.

calculateLocalPosSVG2()

KRITAGLOBAL_EXPORT QPointF KisBezierUtils::calculateLocalPosSVG2	(	const std::array< QPointF, 12 > &	points,
		const QPointF &	globalPoint )

calculates local (u,v) coordinates of the patch corresponding to globalPoint

The function uses SVG2 toon patches algorithm

Parameters

points	control points as laid out in KisBezierPatch
globalPoint	point in global coordinates

Returns

point in local coordinates

Definition at line 920 of file KisBezierUtils.cpp.

{
   return calculateLocalPosImpl<SvgPatchMethod>(points, globalPoint);
}

controlPolygonZeros()

KRITAGLOBAL_EXPORT int KisBezierUtils::controlPolygonZeros

(

const QList< QPointF > &

controlPoints

)

Definition at line 491 of file KisBezierUtils.cpp.

{
    return static_cast<int>(BezierSegment::controlPolygonZeros(controlPoints));
}

References KisBezierUtils::BezierSegment::controlPolygonZeros().

curveLength()

KRITAGLOBAL_EXPORT qreal KisBezierUtils::curveLength	(	const QPointF	p0,
		const QPointF	p1,
		const QPointF	p2,
		const QPointF	p3,
		const qreal	error )

Definition at line 980 of file KisBezierUtils.cpp.

{
    /*
     * This algorithm is implemented based on an idea by Jens Gravesen:
     * "Adaptive subdivision and the length of Bezier curves" mat-report no. 1992-10, Mathematical Institute,
     * The Technical University of Denmark.
     *
     * By subdividing the curve at parameter value t you only have to find the length of a full Bezier curve.
     * If you denote the length of the control polygon by L1 i.e.:
     *   L1 = |P0 P1| +|P1 P2| +|P2 P3|
     *
     * and the length of the cord by L0 i.e.:
     *   L0 = |P0 P3|
     *
     * then
     *   L = 1/2*L0 + 1/2*L1
     *
     * is a good approximation to the length of the curve, and the difference
     *   ERR = L1-L0
     *
     * is a measure of the error. If the error is to large, then you just subdivide curve at parameter value
     * 1/2, and find the length of each half.
     * If m is the number of subdivisions then the error goes to zero as 2^-4m.
     * If you don't have a cubic curve but a curve of degree n then you put
     *   L = (2*L0 + (n-1)*L1)/(n+1)
     */
 
    const int deg = bezierDegree(p0, p1, p2, p3);
 
    if (deg == -1)
        return 0.0;
 
    // calculate chord length
    const qreal chordLen = kisDistance(p0, p3);
 
    if (deg == 1) {
        return chordLen;
    }
 
    // calculate length of control polygon
    qreal polyLength = 0.0;
 
    polyLength += kisDistance(p0, p1);
    polyLength += kisDistance(p1, p2);
    polyLength += kisDistance(p2, p3);
 
    if ((polyLength - chordLen) > error) {
        QPointF q0, q1, q2, q3, q4;
        deCasteljau(p0, p1, p2, p3, 0.5, &q0, &q1, &q2, &q3, &q4);
 
        return curveLength(p0, q0, q1, q2, error) +
                curveLength(q2, q3, q4, p3, error);
    } else {
        // the error is smaller than our tolerance
        if (deg == 3)
            return 0.5 * chordLen + 0.5 * polyLength;
        else
            return (2.0 * chordLen + polyLength) / 3.0;
    }
}

References bezierDegree(), curveLength(), deCasteljau(), kisDistance(), p0, p1, p2, p3, q0, q1, q2, and q3.

curveLengthAtPoint()

KRITAGLOBAL_EXPORT qreal KisBezierUtils::curveLengthAtPoint	(	const QPointF	p0,
		const QPointF	p1,
		const QPointF	p2,
		const QPointF	p3,
		qreal	t,
		const qreal	error )

Definition at line 1041 of file KisBezierUtils.cpp.

{
    QPointF q0, q1, q2, q3, q4;
    deCasteljau(p0, p1, p2, p3, t, &q0, &q1, &q2, &q3, &q4);
 
    return curveLength(p0, q0, q1, q2, error);
}

References curveLength(), deCasteljau(), p0, p1, p2, p3, q0, q1, q2, and q3.

curveParamByProportion()

KRITAGLOBAL_EXPORT qreal KisBezierUtils::curveParamByProportion	(	const QPointF	p0,
		const QPointF	p1,
		const QPointF	p2,
		const QPointF	p3,
		qreal	proportion,
		const qreal	error )

Definition at line 1068 of file KisBezierUtils.cpp.

{
    const qreal totalLength = curveLength(p0, p1, p2, p3, error);
    const qreal expectedLength = proportion * totalLength;
 
    return curveParamBySegmentLength(p0, p1, p2, p3, expectedLength, totalLength, error);
}

References curveLength(), curveParamBySegmentLength(), p0, p1, p2, and p3.

curveParamBySegmentLength()

qreal KisBezierUtils::curveParamBySegmentLength	(	const QPointF	p0,
		const QPointF	p1,
		const QPointF	p2,
		const QPointF	p3,
		qreal	expectedLength,
		qreal	totalLength,
		const qreal	error )

Definition at line 1049 of file KisBezierUtils.cpp.

{
    const qreal splitAtParam = expectedLength / totalLength;
 
    QPointF q0, q1, q2, q3, q4;
    deCasteljau(p0, p1, p2, p3, splitAtParam, &q0, &q1, &q2, &q3, &q4);
 
    const qreal portionLength = curveLength(p0, q0, q1, q2, error);
 
    if (std::abs(portionLength - expectedLength) < error) {
        return splitAtParam;
    } else if (portionLength < expectedLength) {
        return splitAtParam + (1.0 - splitAtParam) * curveParamBySegmentLength(q2, q3, q4, p3, expectedLength - portionLength, totalLength - portionLength, error);
    } else {
        return splitAtParam * curveParamBySegmentLength(p0, q0, q1, q2, expectedLength, portionLength, error);
    }
}

References curveLength(), curveParamBySegmentLength(), deCasteljau(), p0, p1, p2, p3, q0, q1, q2, and q3.

curveProportionByParam()

KRITAGLOBAL_EXPORT qreal KisBezierUtils::curveProportionByParam	(	const QPointF	p0,
		const QPointF	p1,
		const QPointF	p2,
		const QPointF	p3,
		qreal	t,
		const qreal	error )

Definition at line 1076 of file KisBezierUtils.cpp.

{
    return curveLengthAtPoint(p0, p1, p2, p3, t, error) / curveLength(p0, p1, p2, p3, error);
}

References curveLength(), curveLengthAtPoint(), p0, p1, p2, and p3.

deCasteljau()

void KisBezierUtils::deCasteljau ( const QPointF & q0, const QPointF & q1, const QPointF & q2, const QPointF & q3, qreal t, QPointF * p0, QPointF * p1, QPointF * p2, QPointF * p3, QPointF * p4 )

inline

Definition at line 52 of file KisBezierUtils.h.

{
    QPointF q[4];
 
    q[0] = q0;
    q[1] = q1;
    q[2] = q2;
    q[3] = q3;
 
    // points of the new segment after the split point
    QPointF p[3];
 
    // the De Casteljau algorithm
    for (unsigned short j = 1; j <= 3; ++j) {
        for (unsigned short i = 0; i <= 3 - j; ++i) {
            q[i] = (1.0 - t) * q[i] + t * q[i + 1];
        }
        p[j - 1] = q[0];
    }
 
    *p0 = p[0];
    *p1 = p[1];
    *p2 = p[2];
    *p3 = q[1];
    *p4 = q[2];
}

References p, p0, p1, p2, p3, q0, q1, q2, and q3.

interpolateQuadric()

KRITAGLOBAL_EXPORT QPointF KisBezierUtils::interpolateQuadric	(	const QPointF &	p0,
		const QPointF &	p2,
		const QPointF &	pt,
		qreal	t )

Interpolates quadric curve passing through given points.

Interpolates quadric curve passing through p0, pt and p2 with ensuring that pt placed at position t

Returns

interpolated value for control point p1

Definition at line 930 of file KisBezierUtils.cpp.

{
    if (t <= 0.0 || t >= 1.0)
        return lerp(p0, p2, 0.5);
 
    /*
        B(t) = [x2 y2] = (1-t)^2*P0 + 2t*(1-t)*P1 + t^2*P2
 
               B(t) - (1-t)^2*P0 - t^2*P2
         P1 =  --------------------------
                       2t*(1-t)
    */
 
    QPointF c1 = pt - (1.0-t) * (1.0-t)*p0 - t * t * p2;
 
    qreal denom = 2.0 * t * (1.0-t);
 
    c1.rx() /= denom;
    c1.ry() /= denom;
 
    return c1;
}

References lerp(), p0, and p2.

intersectWithLine()

KRITAGLOBAL_EXPORT QVector< qreal > KisBezierUtils::intersectWithLine	(	const QPointF &	p0,
		const QPointF &	p1,
		const QPointF &	p2,
		const QPointF &	p3,
		const QLineF &	line,
		qreal	eps )

Find intersection points (their parameter values) between a cubic Bezier curve and a line.

Curve: p0, p1, p2, p3 Line: line

For cubic Bezier curves there can be at most three intersection points.

Definition at line 1242 of file KisBezierUtils.cpp.

{
    return intersectWithLineImpl(p0, p1, p2, p3, line, eps, 1.0, 0.0);
}

References eps, intersectWithLineImpl(), p0, p1, p2, and p3.

intersectWithLineImpl()

QVector< qreal > KisBezierUtils::intersectWithLineImpl	(	const QPointF &	p0,
		const QPointF &	p1,
		const QPointF &	p2,
		const QPointF &	p3,
		const QLineF &	line,
		qreal	eps,
		qreal	alpha,
		qreal	beta )

Definition at line 1208 of file KisBezierUtils.cpp.

{
    using KisAlgebra2D::intersectLines;
 
    QVector<qreal> result;
 
    const qreal length =
            kisDistance(p0, p1) +
            kisDistance(p1, p2) +
            kisDistance(p2, p3);
 
    if (length < eps) {
        if (intersectLines(p0, p3, line.p1(), line.p2())) {
            result << alpha * 0.5 + beta;
        }
    } else {
 
        const bool hasIntersections =
                intersectLines(p0, p1, line.p1(), line.p2()) ||
                intersectLines(p1, p2, line.p1(), line.p2()) ||
                intersectLines(p2, p3, line.p1(), line.p2());
 
        if (hasIntersections) {
            QPointF q0, q1, q2, q3, q4;
 
            deCasteljau(p0, p1, p2, p3, 0.5, &q0, &q1, &q2, &q3, &q4);
 
            result << intersectWithLineImpl(p0, q0, q1, q2, line, eps, 0.5 * alpha, beta);
            result << intersectWithLineImpl(q2, q3, q4, p3, line, eps, 0.5 * alpha, beta + 0.5 * alpha);
        }
    }
    return result;
}

References deCasteljau(), eps, KisAlgebra2D::intersectLines(), intersectWithLineImpl(), kisDistance(), length(), p0, p1, p2, p3, q0, q1, q2, and q3.

intersectWithLineNearest()

KRITAGLOBAL_EXPORT boost::optional< qreal > KisBezierUtils::intersectWithLineNearest	(	const QPointF &	p0,
		const QPointF &	p1,
		const QPointF &	p2,
		const QPointF &	p3,
		const QLineF &	line,
		const QPointF &	nearestAnchor,
		qreal	eps )

Find new nearest intersection point between a cubic Bezier curve and a line. The resulting point will be the nearest to nearestAnchor.

Definition at line 1247 of file KisBezierUtils.cpp.

{
    QVector<qreal> result = intersectWithLine(p0, p1, p2, p3, line, eps);
 
    qreal minDistance = std::numeric_limits<qreal>::max();
    boost::optional<qreal> nearestRoot;
 
    Q_FOREACH (qreal root, result) {
        const QPointF pt = bezierCurve(p0, p1, p2, p3, root);
        const qreal distance = kisDistance(pt, nearestAnchor);
 
        if (distance < minDistance) {
            minDistance = distance;
            nearestRoot = root;
        }
    }
 
    return nearestRoot;
}

References bezierCurve(), distance(), eps, intersectWithLine(), kisDistance(), p0, p1, p2, and p3.

isLinearSegmentByControlPoints()

bool KisBezierUtils::isLinearSegmentByControlPoints ( const QPointF & p0, const QPointF & p1, const QPointF & p2, const QPointF & p3, const qreal eps = 1e-4 )

inline

Definition at line 151 of file KisBezierUtils.h.

{
    return isLinearSegmentByDerivatives(p0, (p1 - p0) * 3.0, p3, (p3 - p2) * 3.0, eps);
}

References eps, isLinearSegmentByDerivatives(), p0, p1, p2, and p3.

isLinearSegmentByDerivatives()

bool KisBezierUtils::isLinearSegmentByDerivatives ( const QPointF & p0, const QPointF & d0, const QPointF & p1, const QPointF & d1, const qreal eps = 1e-4 )

inline

Definition at line 131 of file KisBezierUtils.h.

{
    const QPointF diff = p1 - p0;
    const qreal dist = KisAlgebra2D::norm(diff);
 
    const qreal normCoeff = 1.0 / 3.0 / dist;
 
    const qreal offset1 =
        normCoeff * qAbs(KisAlgebra2D::crossProduct(diff, d0));
    if (offset1 > eps) return false;
 
    const qreal offset2 =
        normCoeff * qAbs(KisAlgebra2D::crossProduct(diff, d1));
    if (offset2 > eps) return false;
 
    return true;
}

References KisAlgebra2D::crossProduct(), eps, KisAlgebra2D::norm(), p0, and p1.

linearizeCurve()

KRITAGLOBAL_EXPORT QVector< qreal > KisBezierUtils::linearizeCurve	(	const QPointF	p0,
		const QPointF	p1,
		const QPointF	p2,
		const QPointF	p3,
		const qreal	eps )

Definition at line 29 of file KisBezierUtils.cpp.

{
    const qreal minStepSize = 2.0 / kisDistance(p0, p3);
 
    QVector<qreal> steps;
    steps << 0.0;
 
 
    QStack<std::tuple<QPointF, QPointF, qreal>> stackedPoints;
    stackedPoints.push(std::make_tuple(p3, 3 * (p3 - p2), 1.0));
 
    QPointF lastP = p0;
    QPointF lastD = 3 * (p1 - p0);
    qreal lastT = 0.0;
 
    while (!stackedPoints.isEmpty()) {
        QPointF p = std::get<0>(stackedPoints.top());
        QPointF d = std::get<1>(stackedPoints.top());
        qreal t = std::get<2>(stackedPoints.top());
 
        if (t - lastT < minStepSize ||
                isLinearSegmentByDerivatives(lastP, lastD, p, d, eps)) {
 
            lastP = p;
            lastD = d;
            lastT = t;
            steps << t;
            stackedPoints.pop();
        } else {
            t = 0.5 * (lastT + t);
            p = bezierCurve(p0, p1, p2, p3, t);
            d = bezierCurveDeriv(p0, p1, p2, p3, t);
 
            stackedPoints.push(std::make_tuple(p, d, t));
        }
    }
 
    return steps;
}

References bezierCurve(), bezierCurveDeriv(), eps, isLinearSegmentByDerivatives(), kisDistance(), p, p0, p1, p2, and p3.

mergeLinearizationSteps()

KRITAGLOBAL_EXPORT QVector< qreal > KisBezierUtils::mergeLinearizationSteps	(	const QVector< qreal > &	a,
		const QVector< qreal > &	b )

Definition at line 69 of file KisBezierUtils.cpp.

{
    QVector<qreal> result;
 
    std::merge(a.constBegin(), a.constEnd(),
               b.constBegin(), b.constEnd(),
               std::back_inserter(result));
    result.erase(
                std::unique(result.begin(), result.end(),
                            [] (qreal x, qreal y) { return qFuzzyCompare(x, y); }),
            result.end());
 
    return result;
}

nearestPoint()

KRITAGLOBAL_EXPORT qreal KisBezierUtils::nearestPoint	(	const QList< QPointF >	controlPoints,
		const QPointF &	point,
		qreal *	resultDistance,
		QPointF *	resultPoint )

Definition at line 324 of file KisBezierUtils.cpp.

{
    const int deg = controlPoints.size() - 1;
 
    // use shortcut for line segments
    if (deg == 1) {
        // the segments chord
        QPointF chord = controlPoints.last() - controlPoints.first();
        // the point relative to the segment
        QPointF relPoint = point - controlPoints.first();
        // project point to chord (dot product)
        qreal scale = chord.x() * relPoint.x() + chord.y() * relPoint.y();
        // normalize using the chord length
        scale /= chord.x() * chord.x() + chord.y() * chord.y();
 
        if (scale < 0.0) {
            return 0.0;
        } else if (scale > 1.0) {
            return 1.0;
        } else {
            return scale;
        }
    }
 
    /* This function solves the "nearest point on curve" problem. That means, it
    * calculates the point q (to be precise: it's parameter t) on this segment, which
    * is located nearest to the input point P.
    * The basic idea is best described (because it is freely available) in "Phoenix:
    * An Interactive Curve Design System Based on the Automatic Fitting of
    * Hand-Sketched Curves", Philip J. Schneider (Master thesis, University of
    * Washington).
    *
    * For the nearest point q = C(t) on this segment, the first derivative is
    * orthogonal to the distance vector "C(t) - P". In other words we are looking for
    * solutions of f(t) = (C(t) - P) * C'(t) = 0.
    * (C(t) - P) is a nth degree curve, C'(t) a n-1th degree curve => f(t) is a
    * (2n - 1)th degree curve and thus has up to 2n - 1 distinct solutions.
    * We solve the problem f(t) = 0 by using something called "Approximate Inversion Method".
    * Let's write f(t) explicitly (with c_i = p_i - P and d_j = p_{j+1} - p_j):
    *
    *         n                     n-1
    * f(t) = SUM c_i * B^n_i(t)  *  SUM d_j * B^{n-1}_j(t)
    *        i=0                    j=0
    *
    *         n  n-1
    *      = SUM SUM w_{ij} * B^{2n-1}_{i+j}(t)
    *        i=0 j=0
    *
    * with w_{ij} = c_i * d_j * z_{ij} and
    *
    *          BinomialCoeff(n, i) * BinomialCoeff(n - i ,j)
    * z_{ij} = -----------------------------------------------
    *                   BinomialCoeff(2n - 1, i + j)
    *
    * This Bernstein-Bezier polynom representation can now be solved for its roots.
    */
 
    QList<QPointF> ctlPoints = controlPoints;
 
    // Calculate the c_i = point(i) - P.
    QPointF * c_i = new QPointF[ deg + 1 ];
 
    for (int i = 0; i <= deg; ++i) {
        c_i[ i ] = ctlPoints[ i ] - point;
    }
 
    // Calculate the d_j = point(j + 1) - point(j).
    QPointF *d_j = new QPointF[deg];
 
    for (int j = 0; j <= deg - 1; ++j) {
        d_j[j] = 3.0 * (ctlPoints[j+1] - ctlPoints[j]);
    }
 
    // Calculate the dot products of c_i and d_i.
    qreal *products = new qreal[deg * (deg + 1)];
 
    for (int j = 0; j <= deg - 1; ++j) {
        for (int i = 0; i <= deg; ++i) {
            products[j * (deg + 1) + i] = d_j[j].x() * c_i[i].x() + d_j[j].y() * c_i[i].y();
        }
    }
 
    // We don't need the c_i and d_i anymore.
    delete[] d_j ;
    delete[] c_i ;
 
    // Calculate the control points of the new 2n-1th degree curve.
    BezierSegment newCurve;
    newCurve.setDegree(2 * deg - 1);
    // Set up control points in the (u, f(u))-plane.
    for (unsigned short u = 0; u <= 2 * deg - 1; ++u) {
        newCurve.setPoint(u, QPointF(static_cast<qreal>(u) / static_cast<qreal>(2 * deg - 1), 0.0));
    }
 
    // Precomputed "z" for cubics
    static const qreal z3[3*4] = {1.0, 0.6, 0.3, 0.1, 0.4, 0.6, 0.6, 0.4, 0.1, 0.3, 0.6, 1.0};
    // Precomputed "z" for quadrics
    static const qreal z2[2*3] = {1.0, 2./3., 1./3., 1./3., 2./3., 1.0};
 
    const qreal *z = deg == 3 ? z3 : z2;
 
    // Set f(u)-values.
    for (int k = 0; k <= 2 * deg - 1; ++k) {
        int min = qMin(k, deg);
 
        for (unsigned short i = qMax(0, k - (deg - 1)); i <= min; ++i) {
            unsigned short j = k - i;
 
            // p_k += products[j][i] * z[j][i].
            QPointF currentPoint = newCurve.point(k);
            currentPoint.ry() += products[j * (deg + 1) + i] * z[j * (deg + 1) + i];
            newCurve.setPoint(k, currentPoint);
        }
    }
 
    // We don't need the c_i/d_i dot products and the z_{ij} anymore.
    delete[] products;
 
    // Find roots.
    QList<qreal> rootParams = newCurve.roots();
 
    // Now compare the distances of the candidate points.
 
    // First candidate is the previous knot.
    qreal distanceSquared = kisSquareDistance(point, controlPoints.first());
    qreal minDistanceSquared = distanceSquared;
    qreal resultParam = 0.0;
    if (resultDistance) {
        *resultDistance = std::sqrt(distanceSquared);
    }
    if (resultPoint) {
        *resultPoint = controlPoints.first();
    }
 
    // Iterate over the found candidate params.
    Q_FOREACH (qreal root, rootParams) {
        const QPointF rootPoint = bezierCurve(controlPoints, root);
        distanceSquared = kisSquareDistance(point, rootPoint);
 
        if (distanceSquared < minDistanceSquared) {
            minDistanceSquared = distanceSquared;
            resultParam = root;
            if (resultDistance) {
                *resultDistance = std::sqrt(distanceSquared);
            }
            if (resultPoint) {
                *resultPoint = rootPoint;
            }
        }
    }
 
    // Last candidate is the knot.
    distanceSquared = kisSquareDistance(point, controlPoints.last());
    if (distanceSquared < minDistanceSquared) {
        minDistanceSquared = distanceSquared;
        resultParam = 1.0;
        if (resultDistance) {
            *resultDistance = std::sqrt(distanceSquared);
        }
        if (resultPoint) {
            *resultPoint = controlPoints.last();
        }
    }
 
    return resultParam;
}

References bezierCurve(), kisSquareDistance(), KisBezierUtils::BezierSegment::point(), KisBezierUtils::BezierSegment::roots(), KisBezierUtils::BezierSegment::setDegree(), KisBezierUtils::BezierSegment::setPoint(), and u.

offsetSegment()

KRITAGLOBAL_EXPORT std::pair< QPointF, QPointF > KisBezierUtils::offsetSegment	(	qreal	t,
		const QPointF &	offset )

moves point t of the curve by offset offset

Returns

proposed offsets for points p1 and p2 of the curve

Definition at line 953 of file KisBezierUtils.cpp.

{
    /*
    * method from inkscape, original method and idea borrowed from Simon Budig
    * <simon@gimp.org> and the GIMP
    * cf. app/vectors/gimpbezierstroke.c, gimp_bezier_stroke_point_move_relative()
    *
    * feel good is an arbitrary parameter that distributes the delta between handles
    * if t of the drag point is less than 1/6 distance form the endpoint only
    * the corresponding handle is adjusted. This matches the behavior in GIMP
    */
    qreal feel_good;
    if (t <= 1.0 / 6.0)
        feel_good = 0;
    else if (t <= 0.5)
        feel_good = (pow((6 * t - 1) / 2.0, 3)) / 2;
    else if (t <= 5.0 / 6.0)
        feel_good = (1 - pow((6 * (1-t) - 1) / 2.0, 3)) / 2 + 0.5;
    else
        feel_good = 1;
 
    const QPointF moveP1 = ((1-feel_good)/(3*t*(1-t)*(1-t))) * offset;
    const QPointF moveP2 = (feel_good/(3*t*t*(1-t))) * offset;
 
    return std::make_pair(moveP1, moveP2);
}

operator<<()

QDebug KisBezierUtils::operator<<	(	QDebug	dbg,
		const Range &	r )

Definition at line 96 of file KisBezierPatchParamSpaceUtils.h.

{
    dbg.nospace() << "Range(" << r.start << ", " << r.end << ")";
 
    return dbg.space();
}

removeBezierNode()

KRITAGLOBAL_EXPORT std::pair< QPointF, QPointF > KisBezierUtils::removeBezierNode	(	const QPointF &	p0,
		const QPointF &	p1,
		const QPointF &	p2,
		const QPointF &	p3,
		const QPointF &	q1,
		const QPointF &	q2,
		const QPointF &	q3 )

Adjusts position for the bezier control points after removing a node.

First source curve P: p0, p1, p2, p3 Second source curve Q: p3, q1, q2, q3

Node to remove: p3 and its control points p2 and q1

Returns

a pair of new positions for p1 and q2

Calculates the curve control point after removal of a node by minimizing squared error for the following problem:

Given two consequent 3rd order curves P and Q with lengths Lp and Lq, find 3rd order curve B, so that when splitting it at t = Lp / (Lp + Lq) (using de Casteljau algorithm) the control points of the resulting curves will have least square errors, compared to the corresponding control points of curves P and Q.

First we represent curves in matrix form:

B(t) = T * M * B, P(t) = T * Z1 * M * P, Q(t) = T * Z2 * M * Q,

where T = [1, t, t^2, t^3] M — 4x4 matrix of Bezier coefficients B, P, Q — vector of control points for the curves

Z1 — conversion matrix that splits the curve into range [0.0...t] Z2 — conversion matrix that splits the curve into range [t...1.0]

Then we represent vectors P and Q via B:

P = M^(-1) * Z1 * M * B Q = M^(-1) * Z2 * M * B

which in block matrix form looks like:

[ P ] [ M^(-1) * Z1 * M ] | | = | | * B [ Q ] [ M^(-1) * Z2 * M ]

    [ M^(-1) * Z1 * M ]

let C = | |, [ M^(-1) * Z2 * M ]

[ P ] R = | | [ Q ]

then

R = C * B

applying normal equation to find a solution with least square error, get the final result:

B = (C'C)^(-1) * C' * R

Definition at line 1081 of file KisBezierUtils.cpp.

{
    const qreal lenP = KisBezierUtils::curveLength(p0, p1, p2, p3, 0.001);
    const qreal lenQ = KisBezierUtils::curveLength(p3, q1, q2, q3, 0.001);
 
    const qreal z = lenP / (lenP + lenQ);
 
    Eigen::Matrix4f M;
    M << 1, 0, 0, 0,
         -3, 3, 0, 0,
          3, -6, 3, 0,
         -1, 3, -3, 1;
 
    Eigen::DiagonalMatrix<float, 4> Z_1;
    Z_1.diagonal() << 1, z, pow2(z), pow3(z);
 
    Eigen::Matrix4f Z_2;
    Z_2 << 1,     z,         pow2(z),               pow3(z),
           0, 1 - z, 2 * z * (1 - z), 3 * pow2(z) * (1 - z),
           0,     0,     pow2(1 - z),   3 * z * pow2(1 - z),
           0,     0,               0,           pow3(1 - z);
 
    Eigen::Matrix<float, 8, 2> R;
    R << p0.x(), p0.y(),
         p1.x(), p1.y(),
         p2.x(), p2.y(),
         p3.x(), p3.y(),
         p3.x(), p3.y(),
         q1.x(), q1.y(),
         q2.x(), q2.y(),
         q3.x(), q3.y();
 
    Eigen::Matrix<float, 2, 2> B_const;
    B_const << p0.x(), p0.y(),
               q3.x(), q3.y();
 
 
    Eigen::Matrix4f M1 = M.inverse() * Z_1 * M;
    Eigen::Matrix4f M2 = M.inverse() * Z_2 * M;
 
    Eigen::Matrix<float, 8, 4> C;
    C << M1, M2;
 
    Eigen::Matrix<float, 8, 2> C_const;
    C_const << C.col(0), C.col(3);
 
    Eigen::Matrix<float, 8, 2> C_var;
    C_var << C.col(1), C.col(2);
 
    Eigen::Matrix<float, 8, 2> R_var;
    R_var = R - C_const * B_const;
 
    Eigen::Matrix<float, 6, 2> R_reduced;
    R_reduced = R_var.block(1, 0, 6, 2);
 
    Eigen::Matrix<float, 6, 2> C_reduced;
    C_reduced = C_var.block(1, 0, 6, 2);
 
    Eigen::Matrix<float, 2, 2> result;
    result = (C_reduced.transpose() * C_reduced).inverse() * C_reduced.transpose() * R_reduced;
 
    QPointF resultP0(result(0, 0), result(0, 1));
    QPointF resultP1(result(1, 0), result(1, 1));
 
    return std::make_pair(resultP0, resultP1);
}

References C, curveLength(), p0, p1, p2, p3, pow2(), pow3(), q1, q2, q3, and R.