KarbonSimplifyPath Namespace Reference

Functions
bool	isSufficientlyFlat (QPointF curve[4])
void	mergeSubpaths (QList< KoSubpath * > subpaths, KoPathShape *path)
void	removeDuplicates (KoPathShape *path)
void	simplifySubpath (KoSubpath *subpath, qreal error)
void	simplifySubpaths (QList< KoSubpath * > *subpaths, qreal error)
QList< KoSubpath * >	split (const KoPathShape &path)
void	subdivide (KoSubpath *subpath)
KoSubpath	subdivideAux (KoPathPoint *p1, KoPathPoint *p2)

Variables
const int	MAX_RECURSIVE_DEPTH = 1024
int	recursiveDepth
const qreal	SUBDIVISION_COEFF = 100

Function Documentation

isSufficientlyFlat()

bool KarbonSimplifyPath::isSufficientlyFlat

(

QPointF

curve[4]

)

Definition at line 201 of file KarbonSimplifyPath.cpp.

{
    qreal ux = 3 * curve[1].x() - 2 * curve[0].x() - curve[3].x();
    qreal uy = 3 * curve[1].y() - 2 * curve[0].y() - curve[3].y();
    qreal vx = 3 * curve[2].x() - 2 * curve[3].x() - curve[0].x();
    qreal vy = 3 * curve[2].x() - 2 * curve[3].x() - curve[0].x();
 
    // calculate the square of the distance between the points
    qreal dx = curve[0].x() - curve[3].y();
    qreal dy = curve[0].y() - curve[3].y();
    qreal dist2 = dx * dx + dy * dy;
    qreal max2 = qMax(ux * ux, vx * vx) + qMax(uy * uy, vy * vy);
    max2 *= (SUBDIVISION_COEFF * SUBDIVISION_COEFF);
 
    return max2 <= dist2;
}

References SUBDIVISION_COEFF.

mergeSubpaths()

void KarbonSimplifyPath::mergeSubpaths	(	QList< KoSubpath * >	subpaths,
		KoPathShape *	path )

Definition at line 249 of file KarbonSimplifyPath.cpp.

{
    path->clear();
    path->moveTo(subpaths.first()->first()->point());
 
    // TODO: to make the code more readable use foreach and explicit
    //       counters with full name
    // si: subpath index, pi: point index
    for (int si = 0; si < subpaths.size(); ++si) {
        for (int pi = 1; pi < subpaths[si]->size(); ++pi) {
            KoPathPoint *point = (*subpaths[si])[pi];
            path->lineTo(point->point());
 
            // set the first control point
            KoPathPointIndex index(0, path->pointCount() - 1);
            KoPathPoint *p = path->pointByIndex(index);
            if (point->activeControlPoint1()) {
                p->setControlPoint1(point->controlPoint1());
            }
 
            // set the second control point of the previous point
            index = KoPathPointIndex(0, path->pointCount() - 2);
            p = path->pointByIndex(index);
            KoPathPoint *prev = (*subpaths[si])[pi - 1];
            if (prev->activeControlPoint2()) {
                p->setControlPoint2(prev->controlPoint2());
            }
        }
    }
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathShape::clear(), KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, p, KoPathPoint::point, KoPathPoint::setControlPoint1(), and KoPathPoint::setControlPoint2().

removeDuplicates()

void KarbonSimplifyPath::removeDuplicates

(

KoPathShape *

path

)

Definition at line 93 of file KarbonSimplifyPath.cpp.

{
    // NOTE: works because path has only has one subshape, if this ever moves in
    //       KoPathPoint it should be changed
    for (int i = 1; i < path->pointCount(); ++i) {
        KoPathPoint *p = path->pointByIndex(KoPathPointIndex(0, i));
        KoPathPoint *prev = path->pointByIndex(KoPathPointIndex(0, i - 1));
        QPointF diff = p->point() - prev->point();
        // if diff = 0 remove point
        if (qFuzzyCompare(diff.x() + 1, 1) && qFuzzyCompare(diff.y() + 1, 1)) {
            if (prev->activeControlPoint1()) {
                p->setControlPoint1(prev->controlPoint1());
            } else {
                p->removeControlPoint1();
            }
            delete path->removePoint(KoPathPointIndex(0, i - 1));
            --i;
        }
    }
}

References KoPathPoint::activeControlPoint1, KoPathPoint::controlPoint1, p, KoPathPoint::point, and qFuzzyCompare().

simplifySubpath()

void KarbonSimplifyPath::simplifySubpath	(	KoSubpath *	subpath,
		qreal	error )

Definition at line 228 of file KarbonSimplifyPath.cpp.

{
    QList<QPointF> points;
 
    for (int i = 0; i < subpath->size(); ++i) {
        points.append((*subpath)[i]->point());
    }
 
    KoPathShape *simplified = bezierFit(points, error);
 
    qDeleteAll(*subpath);
    subpath->clear();
 
    for (int i = 0; i < simplified->pointCount(); ++i) {
        KoPathPointIndex index(0, i);
        subpath->append(new KoPathPoint(*simplified->pointByIndex(index)));
    }
    //res->setPosition( position() );
    delete simplified;
}

References bezierFit(), KoPathShape::pointByIndex(), and KoPathShape::pointCount().

simplifySubpaths()

void KarbonSimplifyPath::simplifySubpaths	(	QList< KoSubpath * > *	subpaths,
		qreal	error )

Definition at line 218 of file KarbonSimplifyPath.cpp.

{
    Q_FOREACH (KoSubpath *subpath, *subpaths) {
        if (subpath->size() > 2) {
            simplifySubpath(subpath, error);
        }
    }
}

References simplifySubpath().

split()

QList< KoSubpath * > KarbonSimplifyPath::split

(

const KoPathShape &

path

)

Definition at line 114 of file KarbonSimplifyPath.cpp.

{
    QList<KoSubpath *> res;
    KoSubpath *subpath = new KoSubpath;
    res.append(subpath);
 
    for (int i = 0; i < path.pointCount(); ++i) {
        KoPathPoint *p = path.pointByIndex(KoPathPointIndex(0, i));
        // if the path separates two subpaths
        // (if it isn't smooth nor the first or last point)
        if (i != 0  &&  i != path.pointCount() - 1) {
            KoPathPoint *prev = path.pointByIndex(KoPathPointIndex(0, i - 1));
            KoPathPoint *next = path.pointByIndex(KoPathPointIndex(0, i + 1));
            if (!p->isSmooth(prev, next)) {
                // create a new subpath
                subpath->append(new KoPathPoint(*p));
                subpath = new KoSubpath;
                res.append(subpath);
            }
        }
        subpath->append(new KoPathPoint(*p));
    }
 
    return res;
}

References p.

subdivide()

void KarbonSimplifyPath::subdivide

(

KoSubpath *

subpath

)

Definition at line 140 of file KarbonSimplifyPath.cpp.

{
    for (int i = 1; i < subpath->size(); ++i) {
        recursiveDepth = 0;
        KoSubpath newPoints = subdivideAux((*subpath)[i - 1], (*subpath)[i]);
        Q_FOREACH (KoPathPoint *p, newPoints) {
            subpath->insert(i, p);
            ++i;
        }
    }
}

References p, recursiveDepth, and subdivideAux().

subdivideAux()

KoSubpath KarbonSimplifyPath::subdivideAux	(	KoPathPoint *	p1,
		KoPathPoint *	p2 )

Definition at line 152 of file KarbonSimplifyPath.cpp.

{
    if (!p1->activeControlPoint1() && !p2->activeControlPoint2()) {
        return QList<KoPathPoint *>();
    }
 
    QPointF curve[4] = {
        p1->point(),
        p1->activeControlPoint2() ? p1->controlPoint2() : p1->point(),
        p2->activeControlPoint1() ? p2->controlPoint1() : p2->point(),
        p2->point()
    };
 
    // if there is no need to add points do nothing
    if (isSufficientlyFlat(curve)) {
        return QList<KoPathPoint *>();
    }
 
    ++recursiveDepth;
    if (recursiveDepth >= MAX_RECURSIVE_DEPTH) {
        qDebug() << "reached MAX_RECURSIVE_DEPTH";
        --recursiveDepth;
        return QList<KoPathPoint *>();
    }
 
    // calculate the new point using the de Casteljau algorithm
    QPointF p[3];
 
    for (unsigned short j = 1; j <= 3; ++j) {
        for (unsigned short i = 0; i <= 3 - j; ++i) {
            curve[i] = (curve[i] + curve[i + 1]) / 2.0;
        }
        // modify the new segment.
        p[j - 1] = curve[0];
    }
 
    KoPathPoint *pm = new KoPathPoint(0, p[2]);
    pm->setControlPoint1(p[1]);
    pm->setControlPoint2(curve[1]);
    p1->setControlPoint2(p[0]);
    p2->setControlPoint1(curve[2]);
 
    KoSubpath res;
    res << subdivideAux(p1, pm) << pm << subdivideAux(pm, p2);
    --recursiveDepth;
    return res;
}

References isSufficientlyFlat(), MAX_RECURSIVE_DEPTH, p, p1, p2, recursiveDepth, KoPathPoint::setControlPoint1(), KoPathPoint::setControlPoint2(), and subdivideAux().

Variable Documentation

MAX_RECURSIVE_DEPTH

const int KarbonSimplifyPath::MAX_RECURSIVE_DEPTH = 1024

Definition at line 32 of file KarbonSimplifyPath.cpp.

recursiveDepth

int KarbonSimplifyPath::recursiveDepth

Definition at line 33 of file KarbonSimplifyPath.cpp.

SUBDIVISION_COEFF

const qreal KarbonSimplifyPath::SUBDIVISION_COEFF = 100

Definition at line 31 of file KarbonSimplifyPath.cpp.