KisSafeTransform Class Reference

#include <kis_safe_transform.h>

Inheritance diagram for KisSafeTransform:

Public Member Functions
QPolygonF	dstClipPolygon () const
QPolygonF	getCroppedPolygon (const QLineF &baseHorizon, const QRect &rc, const qreal crossCoeff)
qreal	getCrossSign (const QLineF &horizon, const QRectF &rc)
bool	getHorizon (const QTransform &t, QLineF *horizon)
	KisSafeTransform (const QTransform &transform, const QRect &bounds, const QRect &srcInterestRect)
QPolygonF	mapBackward (const QPolygonF &p)
QPolygonF	mapForward (const QPolygonF &p)
QRect	mapRectBackward (const QRect &rc)
QRectF	mapRectBackward (const QRectF &rc)
QRect	mapRectForward (const QRect &rc)
QRectF	mapRectForward (const QRectF &rc)
QPolygonF	srcClipPolygon () const
	~KisSafeTransform ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Attributes
QTransform	backwardTransform
QRect	bounds
QPolygonF	dstClipPolygon
QTransform	forwardTransform
bool	needsClipping = true
QPolygonF	srcClipPolygon
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 19 of file kis_safe_transform.cpp.

Constructor & Destructor Documentation

KisSafeTransform()

KisSafeTransform::KisSafeTransform	(	const QTransform &	transform,
		const QRect &	bounds,
		const QRect &	srcInterestRect )

Definition at line 116 of file kis_safe_transform.cpp.

    : m_d(new Private)
{
    m_d->bounds = bounds;
 
    m_d->forwardTransform = transform;
    m_d->backwardTransform = transform.inverted();
 
    m_d->needsClipping = transform.type() > QTransform::TxShear;
 
    if (m_d->needsClipping) {
        m_d->srcClipPolygon = QPolygonF(QRectF(m_d->bounds));
        m_d->dstClipPolygon = QPolygonF(QRectF(m_d->bounds));
 
        qreal crossCoeff = 1.0;
 
        QLineF srcHorizon;
        if (m_d->getHorizon(m_d->backwardTransform, &srcHorizon)) {
            crossCoeff = m_d->getCrossSign(srcHorizon, srcInterestRect);
            m_d->srcClipPolygon = m_d->getCroppedPolygon(srcHorizon, m_d->bounds, crossCoeff);
        }
 
        QLineF dstHorizon;
        if (m_d->getHorizon(m_d->forwardTransform, &dstHorizon)) {
            crossCoeff = m_d->getCrossSign(dstHorizon, mapRectForward(srcInterestRect));
            m_d->dstClipPolygon = m_d->getCroppedPolygon(dstHorizon, m_d->bounds, crossCoeff);
        }
    }
}

References bounds, m_d, and mapRectForward().

~KisSafeTransform()

KisSafeTransform::~KisSafeTransform

(

)

Definition at line 148 of file kis_safe_transform.cpp.

{
}

Member Function Documentation

dstClipPolygon()

QPolygonF KisSafeTransform::dstClipPolygon

(

)

const

getCroppedPolygon()

QPolygonF KisSafeTransform::getCroppedPolygon ( const QLineF & baseHorizon, const QRect & rc, const qreal crossCoeff )

inline

Definition at line 58 of file kis_safe_transform.cpp.

                                                                                                    {
        if (rc.isEmpty()) return QPolygonF();
 
        QRectF boundsRect(rc);
        QPolygonF polygon(boundsRect);
        QPolygonF result;
 
        // calculate new (offset) horizon to avoid infinity
        const qreal offsetLength = 10.0;
        const QPointF horizonOffset = offsetLength * crossCoeff *
            KisAlgebra2D::rightUnitNormal(baseHorizon.p2() - baseHorizon.p1());
 
        const QLineF horizon = baseHorizon.translated(horizonOffset);
 
        // base vectors to calculate the side of the horizon
        const QPointF &basePoint = horizon.p1();
        const QPointF horizonVec = horizon.p2() - basePoint;
 
 
        // iteration
        QPointF prevPoint = polygon[polygon.size() - 1];
        qreal prevCross = crossCoeff * KisAlgebra2D::crossProduct(horizonVec, prevPoint - basePoint);
 
        for (int i = 0; i < polygon.size(); i++) {
            const QPointF &pt = polygon[i];
 
            qreal cross = crossCoeff * KisAlgebra2D::crossProduct(horizonVec, pt - basePoint);
 
            if ((cross >= 0 && prevCross >= 0) || (cross == 0 && prevCross < 0)) {
                result << pt;
            } else if (cross * prevCross < 0) {
                QPointF intersection;
                QLineF edge(prevPoint, pt);
                QLineF::IntersectType intersectionType =
                    horizon.intersects(edge, &intersection);
 
                KIS_ASSERT_RECOVER_NOOP(intersectionType != QLineF::NoIntersection);
 
                result << intersection;
 
                if (cross > 0) {
                    result << pt;
                }
            }
 
            prevPoint = pt;
            prevCross = cross;
        }
 
        if (result.size() > 0 && !result.isClosed()) {
            result << result.first();
        }
 
        return result;
    }

References KisAlgebra2D::crossProduct(), KIS_ASSERT_RECOVER_NOOP, and KisAlgebra2D::rightUnitNormal().

getCrossSign()

qreal KisSafeTransform::getCrossSign ( const QLineF & horizon, const QRectF & rc )

inline

Definition at line 51 of file kis_safe_transform.cpp.

                                                                {
        if (rc.isEmpty()) return 1.0;
 
        QPointF diff = horizon.p2() - horizon.p1();
        return KisAlgebra2D::signPZ(KisAlgebra2D::crossProduct(diff, rc.center() - horizon.p1()));
    }

References KisAlgebra2D::crossProduct(), and KisAlgebra2D::signPZ().

getHorizon()

bool KisSafeTransform::getHorizon ( const QTransform & t, QLineF * horizon )

inline

Definition at line 30 of file kis_safe_transform.cpp.

                                                          {
        static const qreal eps = 1e-10;
 
        QPointF vanishingX(t.m11() / t.m13(), t.m12() / t.m13());
        QPointF vanishingY(t.m21() / t.m23(), t.m22() / t.m23());
 
        if (qAbs(t.m13()) < eps && qAbs(t.m23()) < eps) {
            *horizon = QLineF();
            return false;
        } else if (qAbs(t.m23()) < eps) {
            QPointF diff = t.map(QPointF(0.0, 10.0)) - t.map(QPointF());
            vanishingY = vanishingX + diff;
        } else if (qAbs(t.m13()) < eps) {
            QPointF diff = t.map(QPointF(10.0, 0.0)) - t.map(QPointF());
            vanishingX = vanishingY + diff;
        }
 
        *horizon = QLineF(vanishingX, vanishingY);
        return true;
    }

References eps.

mapBackward()

QPolygonF KisSafeTransform::mapBackward

(

const QPolygonF &

p

)

Definition at line 176 of file kis_safe_transform.cpp.

{
    QPolygonF poly;
 
    if (!m_d->needsClipping) {
        poly = m_d->backwardTransform.map(p);
    } else {
        poly = m_d->dstClipPolygon.intersected(p);
        poly = m_d->backwardTransform.map(poly).intersected(QRectF(m_d->bounds));
    }
 
    return poly;
}

References m_d, and p.

mapForward()

QPolygonF KisSafeTransform::mapForward

(

const QPolygonF &

p

)

Definition at line 162 of file kis_safe_transform.cpp.

{
    QPolygonF poly;
 
    if (!m_d->needsClipping) {
        poly = m_d->forwardTransform.map(p);
    } else {
        poly = m_d->srcClipPolygon.intersected(p);
        poly = m_d->forwardTransform.map(poly).intersected(QRectF(m_d->bounds));
    }
 
    return poly;
}

References m_d, and p.

mapRectBackward() [1/2]

QRect KisSafeTransform::mapRectBackward

(

const QRect &

rc

)

Definition at line 205 of file kis_safe_transform.cpp.

{
    return mapRectBackward(QRectF(rc)).toAlignedRect();
}

References mapRectBackward().

mapRectBackward() [2/2]

QRectF KisSafeTransform::mapRectBackward

(

const QRectF &

rc

)

Definition at line 195 of file kis_safe_transform.cpp.

{
    return mapBackward(rc).boundingRect();
}

References mapBackward().

mapRectForward() [1/2]

QRect KisSafeTransform::mapRectForward

(

const QRect &

rc

)

Definition at line 200 of file kis_safe_transform.cpp.

{
    return mapRectForward(QRectF(rc)).toAlignedRect();
}

References mapRectForward().

mapRectForward() [2/2]

QRectF KisSafeTransform::mapRectForward

(

const QRectF &

rc

)

Definition at line 190 of file kis_safe_transform.cpp.

{
    return mapForward(rc).boundingRect();
}

References mapForward().

srcClipPolygon()

QPolygonF KisSafeTransform::srcClipPolygon

(

)

const

Member Data Documentation

backwardTransform

QTransform KisSafeTransform::backwardTransform

Definition at line 25 of file kis_safe_transform.cpp.

bounds

QRect KisSafeTransform::bounds

Definition at line 23 of file kis_safe_transform.cpp.

dstClipPolygon

QPolygonF KisSafeTransform::dstClipPolygon

Definition at line 28 of file kis_safe_transform.cpp.

forwardTransform

QTransform KisSafeTransform::forwardTransform

Definition at line 24 of file kis_safe_transform.cpp.

m_d

const QScopedPointer<Private> KisSafeTransform::m_d

private

Definition at line 43 of file kis_safe_transform.h.

needsClipping

bool KisSafeTransform::needsClipping = true

Definition at line 21 of file kis_safe_transform.cpp.

srcClipPolygon

QPolygonF KisSafeTransform::srcClipPolygon

Definition at line 27 of file kis_safe_transform.cpp.

---

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

• libs/image/kis_safe_transform.cpp
• libs/image/kis_safe_transform.h