Changeset 73 for trunk/src/canvas/qcanvas.cpp

Timestamp:

Mar 24, 2006, 12:46:08 AM (19 years ago)

Author:

dmik

Message:

Fixed all the drawing artefacts and distortions seen when applying non-identity transformations to canvas views.

File:

• trunk/src/canvas/qcanvas.cpp (modified) (8 diffs)

trunk/src/canvas/qcanvas.cpp

@@ -49 +49 @@
 #include <stdlib.h>
 
+//#define QT_NO_CANVAS_ROUNDING_FIX
+
+#if !defined(QT_NO_TRANSFORMATIONS) && !defined(QT_NO_CANVAS_ROUNDING_FIX)
+#include <math.h>
+#endif
+
 class QCanvasData {
 public:
@@ -108 +114 @@
     }
 }
+
+#if !defined(QT_NO_TRANSFORMATIONS) && !defined(QT_NO_CANVAS_ROUNDING_FIX)
+
+/*!
+ * \internal
+ *
+ * Takes inclusive top left and exclusive bottom right poitns of the given
+ * rectangle, translates it using the given matrix, calculates the bounding
+ * rectangle and converts resulting doubles to integers so that points of the
+ * target raster partially covered by resulting double points are included
+ * to the resulting rectangle.
+ *
+ * Using this function instead of QWMatrix::map(const QRect&) eliminates many
+ * artefacts and distortions seen in canvas views that use world transformation.
+ * When scaling up, this function works merely as QWMatrix::map() with
+ * transformation mode set to Areas, but it also produces correct rectangles
+ * (as necessary to determine affected chunks) in all other cases. 
+ */
+static
+QRect mapRectMax( const QWMatrix &m, const QRect &r )
+{
+    if ( m.isIdentity() ) {
+        return r;
+    }
+    
+    QRect rect = r;
+
+    // make bottom right exclusive
+    ++ rect.rBottom();
+    ++ rect.rRight();
+    
+    double x1, y1, x2, y2;
+    
+    if ( m.m12() == 0.0 && m.m21() == 0.0 ) {
+        // no shear or rotation, map two coords
+        m.map( rect.left(), rect.top(), &x1, &y1 );
+        m.map( rect.right(), rect.bottom(), &x2, &y2 );
+    } else {
+        double xl = rect.left(), yt = rect.top(); 
+        double xr = rect.right(), yb = rect.bottom(); 
+        double x, y;
+        // map four coords and find min/max
+        m.map( xl, yt, &x, &y );
+        x1 = x;
+        y1 = y;
+        x2 = x;
+        y2 = y;
+        m.map( xr, yt, &x, &y );
+        x1 = QMIN( x1, x );
+        y1 = QMIN( y1, y );
+        x2 = QMAX( x2, x );
+        y2 = QMAX( y2, y );
+        m.map( xl, yb, &x, &y );
+        x1 = QMIN( x1, x );
+        y1 = QMIN( y1, y );
+        x2 = QMAX( x2, x );
+        y2 = QMAX( y2, y );
+        m.map( xr, yb, &x, &y );
+        x1 = QMIN( x1, x );
+        y1 = QMIN( y1, y );
+        x2 = QMAX( x2, x );
+        y2 = QMAX( y2, y );
+    }
+    
+    // get integers (partially covered points are included)
+    x1 = floor( x1 );
+    y1 = floor( y1 );
+    x2 = ceil( x2 );
+    y2 = ceil( y2 );
+    
+    // compose the result
+    rect.setCoords( int( x1 ), int( y1 ), int( x2 ), int( y2 ) );
+    // make bottom right inclusive again
+    -- rect.rBottom();
+    -- rect.rRight();
+    
+    return rect;
+}
+
+/*!
+ * \internal
+ *
+ * Similar to mapRectMax, but with the opposite meaning. Tries to return
+ * a region that is completely inside the given rectangle after transformation.
+ * \a br is the target bounding rectangle (to minimize calculations).
+ *
+ * Using this function to clip out areas of the canvas view not covered by the
+ * canvas eliminates garbage at canvas edges that can be well seen when the
+ * canvas is rotated in the view.
+ */
+static
+QRegion mapRectMin( const QWMatrix &m, const QRect &r, const QRect &br )
+{
+    QRegion rgn;
+    
+    if ( m.isIdentity() ) {
+        rgn = QRegion( r );
+        return rgn; 
+    }
+
+    if ( m.m12() == 0.0 && m.m21() == 0.0 ) {
+        QRect rect = r;    
+        // make bottom right exclusive
+        ++ rect.rBottom();
+        ++ rect.rRight();
+        double x1, y1, x2, y2;
+        // no shear or rotation, map two coords
+        m.map( rect.left(), rect.top(), &x1, &y1 );
+        m.map( rect.right(), rect.bottom(), &x2, &y2 );
+        // get integers (partially covered points are excluded)
+        x1 = ceil( x1 );
+        y1 = ceil( y1 );
+        x2 = floor( x2 );
+        y2 = floor( y2 );
+        // compose the result
+        rect.setCoords( int( x1 ), int( y1 ), int( x2 ), int( y2 ) );
+        // make bottom right inclusive again
+        -- rect.rBottom();
+        -- rect.rRight();
+        rgn = QRegion( rect );
+    } else {
+        // make the rectangle smaller to compensate for differences in
+        // line drawing routines of the underlying OS (when defining regions
+        // from polygons) and by Qt tansformations (when transforming images
+        // or when determining invalid chunks)
+        QPointArray pa( r );
+        pa = m.map( pa );
+        rgn = QRegion( pa );
+        // limit to the bounding rect (expanded to compensate shifts)
+        QRect rect = br;
+        rect.addCoords( -1, 0, 1, 0 );
+        rgn &= QRegion( rect );
+        // create a copy of the region and shift each towards other by 1 pixel
+        // to compensate for (clip out) differences in line drawing routines of
+        // the underlying OS (when defining regions from polygons) and in Qt
+        // tansformation routines (when transforming images or when determining
+        // invalid chunks)
+        QRegion rgn2 = rgn;
+        rgn.translate( 1, 0 );
+        rgn2.translate( -1, 0 );
+        // take an intersection
+        rgn &= rgn2;
+    }
+    
+    return rgn;
+}
+
+#endif
 
 /*
@@ -1069 +1223 @@
     QWMatrix iwm = wm.invert();
     // ivr = covers all chunks in vr
+#if !defined(QT_NO_CANVAS_ROUNDING_FIX)
+    QRect ivr = vr;
+    if ( wm.m12() != 0.0 || wm.m21() != 0.0 ) {
+        // compensate for rounding errors happening on the path
+        // update() -> drawViewArea() after many transformations (can be seen
+        // when moving items in a canvas view that makes the canvas smaller
+        // and rotates it to ~270 degress clockwise)
+        ivr.addCoords( -1, -1, 1, 1 );
+    }
+    ivr = mapRectMax( iwm, ivr );
+#else
     QRect ivr = iwm.map(vr);
+#endif    
     QWMatrix twm;
     twm.translate(tl.x(),tl.y());
@@ -1082 +1248 @@
 
 #ifndef QT_NO_TRANSFORMATIONS
+#if !defined(QT_NO_CANVAS_ROUNDING_FIX)
+        QRect cvr = vr; cvr.moveBy(tl.x(),tl.y());
+        QRegion ra = mapRectMin( wm * twm, all, cvr ); 
+#else        
 #if !defined(Q_WS_PM)
         // For translation-only transformation, it is safe to include the right
@@ -1092 +1262 @@
             a = QPointArray( all );
 #else
-        // Polygons on OS/2 already include the right and bottom edges
+        // Polygons in OS/2 already include the right and bottom edges
         // (why shouldn't they do that?) Indeed, this important moment is not
         // defined in Qt at all. 
         QPointArray a( all );
 #endif
-
         a = (wm*twm).map(a);
+#endif        
 #else
 #if !defined(Q_WS_PM)
@@ -1107 +1277 @@
 #endif
         if ( view->viewport()->backgroundMode() == NoBackground ) {
+#if !defined(QT_NO_CANVAS_ROUNDING_FIX)
+            p->setClipRegion( QRegion( cvr ) - ra );
+#else
             QRect cvr = vr; cvr.moveBy(tl.x(),tl.y());
             p->setClipRegion(QRegion(cvr)-QRegion(a));
+#endif 
             p->fillRect(vr,view->viewport()->palette()
                 .brush(QPalette::Active,QColorGroup::Background));
         }
+#if !defined(QT_NO_CANVAS_ROUNDING_FIX)
+        p->setClipRegion( ra );
+#else
         p->setClipRegion(a);
+#endif            
     }
 
@@ -1174 +1352 @@
             if ( !wm.isIdentity() ) {
                 // r = Visible area of the canvas where there are changes
+#if !defined(QT_NO_CANVAS_ROUNDING_FIX)
+                QRect r = changeBounds( mapRectMax( view->inverseWorldMatrix(),
+                                        area ) );
+#else
                 QRect r = changeBounds(view->inverseWorldMatrix().map(area));
+#endif                
                 if ( !r.isEmpty() ) {
                     QPainter p(view->viewport());
@@ -1180 +1363 @@
                     QPoint tl = view->contentsToViewport(QPoint(0,0));
                     p.translate(tl.x(),tl.y());
+#if !defined(QT_NO_CANVAS_ROUNDING_FIX)
+                    drawViewArea( view, &p, mapRectMax( wm, r ), dblbuf );
+#else
                     drawViewArea( view, &p, wm.map(r), dblbuf );
+#endif                    
                     doneareas.append(new QRect(r));
                 }