qtransform.cpp File Reference

#include "qtransform.h"
#include "qdatastream.h"
#include "qdebug.h"
#include "qmatrix.h"
#include "qregion.h"
#include "qpainterpath.h"
#include "qvariant.h"
#include <qmath.h>
#include <qnumeric.h>
#include <private/qbezier_p.h>

Go to the source code of this file.

Classes
struct	QHomogeneousCoordinate

Macros
#define	MAP(x, y, nx, ny)
#define	Q_NEAR_CLIP   (sizeof(qreal) == sizeof(double) ? 0.000001 : 0.0001)

Functions
static bool	cubicTo_clipped (QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b, const QPointF &c, const QPointF &d, bool needsMoveTo)
static bool	lineTo_clipped (QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b, bool needsMoveTo, bool needsLineTo=true)
static QHomogeneousCoordinate	mapHomogeneous (const QTransform &transform, const QPointF &p)
static QPolygonF	mapProjective (const QTransform &transform, const QPolygonF &poly)
static QPainterPath	mapProjective (const QTransform &transform, const QPainterPath &path)
static bool	needsPerspectiveClipping (const QRectF &rect, const QTransform &transform)
QDataStream &	operator<< (QDataStream &s, const QTransform &m)
QDebug	operator<< (QDebug dbg, const QTransform &m)
QDataStream &	operator>> (QDataStream &s, QTransform &t)
Q_AUTOTEST_EXPORT QPainterPath	qt_regionToPath (const QRegion &region)
Q_GUI_EXPORT bool	qt_scaleForTransform (const QTransform &transform, qreal *scale)

Variables
const qreal	deg2rad = qreal(0.017453292519943295769)
const qreal	inv_dist_to_plane = 1. / 1024.

Macro Definition Documentation

MAP

#define MAP	(		x,
			y,
			nx,
			ny
	)

Value:

do { \
        qreal FX_ = x; \
        qreal FY_ = y; \
        switch(t) {   \
        case TxNone:  \
            nx = FX_;   \
            ny = FY_;   \
            break;    \
        case TxTranslate:    \
            nx = FX_ + affine._dx;                \
            ny = FY_ + affine._dy;                \
            break;                              \
        case TxScale:                           \
            nx = affine._m11 * FX_ + affine._dx;  \
            ny = affine._m22 * FY_ + affine._dy;  \
            break;                              \
        case TxRotate:                          \
        case TxShear:                           \
        case TxProject:                                      \
            nx = affine._m11 * FX_ + affine._m21 * FY_ + affine._dx;        \
            ny = affine._m12 * FX_ + affine._m22 * FY_ + affine._dy;        \
            if (t == TxProject) {                                       \
                qreal w = (m_13 * FX_ + m_23 * FY_ + m_33);              \
                if (w < qreal(Q_NEAR_CLIP)) w = qreal(Q_NEAR_CLIP);     \
                w = 1./w;                                               \
                nx *= w;                                                \
                ny *= w;                                                \
            }                                                           \
        }                                                               \
    } while (0)

Definition at line 61 of file qtransform.cpp.

Referenced by QTransform::map(), QTransform::mapRect(), and QTransform::mapToPolygon().

Q_NEAR_CLIP

#define Q_NEAR_CLIP   (sizeof(qreal) == sizeof(double) ? 0.000001 : 0.0001)

Definition at line 56 of file qtransform.cpp.

Referenced by lineTo_clipped(), and needsPerspectiveClipping().

Function Documentation

cubicTo_clipped()

static bool cubicTo_clipped ( QPainterPath &  path, const QTransform &  transform, const QPointF &  a, const QPointF &  b, const QPointF &  c, const QPointF &  d, bool  needsMoveTo  )

inlinestatic

Definition at line 1608 of file qtransform.cpp.

Referenced by mapProjective().

{
    // Convert projective xformed curves to line
    // segments so they can be transformed more accurately

    qreal scale;
    qt_scaleForTransform(transform, &scale);

    qreal curveThreshold = scale == 0 ? qreal(0.25) : (qreal(0.25) / scale);

    QPolygonF segment = QBezier::fromPoints(a, b, c, d).toPolygon(curveThreshold);

    for (int i = 0; i < segment.size() - 1; ++i)
        if (lineTo_clipped(path, transform, segment.at(i), segment.at(i+1), needsMoveTo))
            needsMoveTo = false;

    return !needsMoveTo;
}

lineTo_clipped()

static bool lineTo_clipped ( QPainterPath &  path, const QTransform &  transform, const QPointF &  a, const QPointF &  b, bool  needsMoveTo, bool  needsLineTo = true  )

inlinestatic

Definition at line 1567 of file qtransform.cpp.

Referenced by cubicTo_clipped(), and mapProjective().

{
    QHomogeneousCoordinate ha = mapHomogeneous(transform, a);
    QHomogeneousCoordinate hb = mapHomogeneous(transform, b);

    if (ha.w < Q_NEAR_CLIP && hb.w < Q_NEAR_CLIP)
        return false;

    if (hb.w < Q_NEAR_CLIP) {
        const qreal t = (Q_NEAR_CLIP - hb.w) / (ha.w - hb.w);

        hb.x += (ha.x - hb.x) * t;
        hb.y += (ha.y - hb.y) * t;
        hb.w = qreal(Q_NEAR_CLIP);
    } else if (ha.w < Q_NEAR_CLIP) {
        const qreal t = (Q_NEAR_CLIP - ha.w) / (hb.w - ha.w);

        ha.x += (hb.x - ha.x) * t;
        ha.y += (hb.y - ha.y) * t;
        ha.w = qreal(Q_NEAR_CLIP);

        const QPointF p = ha.toPoint();
        if (needsMoveTo) {
            path.moveTo(p);
            needsMoveTo = false;
        } else {
            path.lineTo(p);
        }
    }

    if (needsMoveTo)
        path.moveTo(ha.toPoint());

    if (needsLineTo)
        path.lineTo(hb.toPoint());

    return true;
}

mapHomogeneous()

static QHomogeneousCoordinate mapHomogeneous ( const QTransform &  transform, const QPointF &  p  )

inlinestatic

Definition at line 1558 of file qtransform.cpp.

Referenced by lineTo_clipped().

{
    QHomogeneousCoordinate c;
    c.x = transform.m11() * p.x() + transform.m21() * p.y() + transform.m31();
    c.y = transform.m12() * p.x() + transform.m22() * p.y() + transform.m32();
    c.w = transform.m13() * p.x() + transform.m23() * p.y() + transform.m33();
    return c;
}

mapProjective() [1/2]

static QPolygonF mapProjective ( const QTransform &  transform, const QPolygonF &  poly  )

static

Definition at line 1393 of file qtransform.cpp.

Referenced by QTransform::map().

{
    if (poly.size() == 0)
        return poly;

    if (poly.size() == 1)
        return QPolygonF() << transform.map(poly.at(0));

    QPainterPath path;
    path.addPolygon(poly);

    path = transform.map(path);

    QPolygonF result;
    for (int i = 0; i < path.elementCount(); ++i)
        result << path.elementAt(i);
    return result;
}

mapProjective() [2/2]

static QPainterPath mapProjective ( const QTransform &  transform, const QPainterPath &  path  )

static

Definition at line 1627 of file qtransform.cpp.

{
    QPainterPath result;

    QPointF last;
    QPointF lastMoveTo;
    bool needsMoveTo = true;
    for (int i = 0; i < path.elementCount(); ++i) {
        switch (path.elementAt(i).type) {
        case QPainterPath::MoveToElement:
            if (i > 0 && lastMoveTo != last)
                lineTo_clipped(result, transform, last, lastMoveTo, needsMoveTo);

            lastMoveTo = path.elementAt(i);
            last = path.elementAt(i);
            needsMoveTo = true;
            break;
        case QPainterPath::LineToElement:
            if (lineTo_clipped(result, transform, last, path.elementAt(i), needsMoveTo))
                needsMoveTo = false;
            last = path.elementAt(i);
            break;
        case QPainterPath::CurveToElement:
            if (cubicTo_clipped(result, transform, last, path.elementAt(i), path.elementAt(i+1), path.elementAt(i+2), needsMoveTo))
                needsMoveTo = false;
            i += 2;
            last = path.elementAt(i);
            break;
        default:
            Q_ASSERT(false);
        }
    }

    if (path.elementCount() > 0 && lastMoveTo != last)
        lineTo_clipped(result, transform, last, lastMoveTo, needsMoveTo, false);

    result.setFillRule(path.fillRule());
    return result;
}

needsPerspectiveClipping()

static bool needsPerspectiveClipping ( const QRectF &  rect, const QTransform &  transform  )

inlinestatic

Definition at line 1912 of file qtransform.cpp.

Referenced by QTransform::mapRect().

{
    const qreal wx = qMin(transform.m13() * rect.left(), transform.m13() * rect.right());
    const qreal wy = qMin(transform.m23() * rect.top(), transform.m23() * rect.bottom());

    return wx + wy + transform.m33() < Q_NEAR_CLIP;
}

operator<<() [1/2]

QDataStream& operator<< ( QDataStream &  s, const QTransform &  m  )

related

Definition at line 1064 of file qtransform.cpp.

Referenced by qFuzzyCompare().

{
    s << double(m.m11())
      << double(m.m12())
      << double(m.m13())
      << double(m.m21())
      << double(m.m22())
      << double(m.m23())
      << double(m.m31())
      << double(m.m32())
      << double(m.m33());
    return s;
}

operator<<() [2/2]

QDebug operator<<	(	QDebug	dbg,
		const QTransform &	m
	)

Definition at line 1115 of file qtransform.cpp.

{
    static const char *typeStr[] =
    {
        "TxNone",
        "TxTranslate",
        "TxScale",
        0,
        "TxRotate",
        0, 0, 0,
        "TxShear",
        0, 0, 0, 0, 0, 0, 0,
        "TxProject"
    };

    dbg.nospace() << "QTransform(type=" << typeStr[m.type()] << ','
                  << " 11=" << m.m11()
                  << " 12=" << m.m12()
                  << " 13=" << m.m13()
                  << " 21=" << m.m21()
                  << " 22=" << m.m22()
                  << " 23=" << m.m23()
                  << " 31=" << m.m31()
                  << " 32=" << m.m32()
                  << " 33=" << m.m33()
                  << ')';

    return dbg.space();
}

operator>>()

QDataStream& operator>> ( QDataStream &  s, QTransform &  t  )

related

Definition at line 1091 of file qtransform.cpp.

Referenced by qFuzzyCompare().

{
     double m11, m12, m13,
         m21, m22, m23,
         m31, m32, m33;

     s >> m11;
     s >> m12;
     s >> m13;
     s >> m21;
     s >> m22;
     s >> m23;
     s >> m31;
     s >> m32;
     s >> m33;
     t.setMatrix(m11, m12, m13,
                 m21, m22, m23,
                 m31, m32, m33);
     return s;
}

qt_regionToPath()

Q_AUTOTEST_EXPORT QPainterPath qt_regionToPath

(

const QRegion &

region

)

Definition at line 1160 of file qregion.cpp.

Referenced by QTransform::map().

{
    QPainterPath result;
    if (region.rectCount() == 1) {
        result.addRect(region.boundingRect());
        return result;
    }

    const QVector<QRect> rects = region.rects();

    QVarLengthArray<Segment> segments;
    segments.resize(4 * rects.size());

    const QRect *rect = rects.constData();
    const QRect *end = rect + rects.size();

    int lastRowSegmentCount = 0;
    Segment *lastRowSegments = 0;

    int lastSegment = 0;
    int lastY = 0;
    while (rect != end) {
        const int y = rect[0].y();
        int count = 0;
        while (&rect[count] != end && rect[count].y() == y)
            ++count;

        for (int i = 0; i < count; ++i) {
            int offset = lastSegment + i;
            segments[offset] = Segment(rect[i].topLeft());
            segments[offset += count] = Segment(rect[i].topRight() + QPoint(1, 0));
            segments[offset += count] = Segment(rect[i].bottomRight() + QPoint(1, 1));
            segments[offset += count] = Segment(rect[i].bottomLeft() + QPoint(0, 1));

            offset = lastSegment + i;
            for (int j = 0; j < 4; ++j)
                segments[offset + j * count].connect(segments[offset + ((j + 1) % 4) * count]);
        }

        if (lastRowSegments && lastY == y)
            mergeSegments(lastRowSegments, lastRowSegmentCount, &segments[lastSegment], count);

        lastRowSegments = &segments[lastSegment + 2 * count];
        lastRowSegmentCount = count;
        lastSegment += 4 * count;
        lastY = y + rect[0].height();
        rect += count;
    }

    for (int i = 0; i < lastSegment; ++i) {
        Segment *segment = &segments[i];
        if (!segment->added)
            addSegmentsToPath(segment, result);
    }

    return result;
}

qt_scaleForTransform()

Q_GUI_EXPORT bool qt_scaleForTransform	(	const QTransform &	transform,
		qreal *	scale
	)

Definition at line 2407 of file qtransform.cpp.

Referenced by QPaintEngineEx::createState(), cubicTo_clipped(), QPixmapBlurFilter::draw(), QGL2PaintEngineEx::fill(), lineTo_clipped(), qt_blurImage(), QStrokerOps::setCurveThresholdFromTransform(), QVGPaintEnginePrivate::setTransform(), QGL2PaintEngineEx::stroke(), QOpenGLPaintEnginePrivate::strokeLines(), QOpenGLPaintEnginePrivate::strokePath(), QX11PaintEngine::updateMatrix(), QRasterPaintEngine::updateMatrix(), and QVGPaintEnginePrivate::updateTransform().

{
    const QTransform::TransformationType type = transform.type();
    if (type <= QTransform::TxTranslate) {
        if (scale)
            *scale = 1;
        return true;
    } else if (type == QTransform::TxScale) {
        const qreal xScale = qAbs(transform.m11());
        const qreal yScale = qAbs(transform.m22());
        if (scale)
            *scale = qMax(xScale, yScale);
        return qFuzzyCompare(xScale, yScale);
    }

    const qreal xScale = transform.m11() * transform.m11()
                         + transform.m21() * transform.m21();
    const qreal yScale = transform.m12() * transform.m12()
                         + transform.m22() * transform.m22();
    if (scale)
        *scale = qSqrt(qMax(xScale, yScale));
    return type == QTransform::TxRotate && qFuzzyCompare(xScale, yScale);
}

Variable Documentation

deg2rad

const qreal deg2rad = qreal(0.017453292519943295769)

Definition at line 595 of file qtransform.cpp.

Referenced by QTransform::rotate().

inv_dist_to_plane

const qreal inv_dist_to_plane = 1. / 1024.

Definition at line 596 of file qtransform.cpp.

Referenced by QTransform::rotate(), and QTransform::rotateRadians().