Improved performance.

Author: dmester

lib/matrix.js

@@ -84,7 +84,7 @@ Matrix.prototype.multiply = function Matrix_multiply(a, b, c, d, e, f) {
  * @param {number} y  Y coordinate.
  * @returns {{x:number, y:number}}
  */
-Matrix.prototype.multiplyPoint = function Matrix_multiply(x, y) {
+Matrix.prototype.multiplyPoint = function Matrix_multiplyPoint(x, y) {
     return {
         x: this._a * x + this._c * y + this._e,
         y: this._b * x + this._d * y + this._f

lib/rasterization/edge.js

@@ -36,8 +36,7 @@ function Edge(polygonId, x0, y0, x1, y1, color, windingRule) {
     this.windingRule = windingRule;
 }
 
-Edge.prototype.intersection = function intersection(y)
-{
+Edge.prototype.intersection = function intersection(y) {
     var dx = (this.x1 - this.x0) * (this.y0 - y) / (this.y0 - this.y1);
     return this.x0 + dx;
 };

lib/rasterization/layerManager.js

@@ -52,6 +52,26 @@ LayerManager.prototype.clear = function LayerManager_clear() {
     this.color = colorUtils.TRANSPARENT;
 };
 
+/**
+ * Copies all layers in this LayerManager to another LayerManager.
+ * @param {LayerManager} other
+ * @public
+ */
+LayerManager.prototype.copyTo = function LayerManager_copyTo(other) {
+    other.color = this.color;
+    other._layers = [];
+    
+    for (var i = 0; i < this._layers.length; i++) {
+        var layer = this._layers[i];
+        other._layers[i] = {
+            color: layer.color,
+            inPath: layer.inPath,
+            polygonId: layer.polygonId,
+            winding: layer.winding
+        };
+    }
+};
+
 /**
  * Adds a layer for the specified edge. The z-order is defined by its id.
  * @param {Edge} edge

lib/rasterization/rasterizer.js

@@ -29,6 +29,7 @@
 const BitmapWriter = require("./bitmapWriter");
 const LayerManager = require("./layerManager");
 const SuperSampleBuffer = require("./superSampleBuffer");
+const colorUtils = require("../colorUtils");
 
 /**
  * A higher number of samples per pixel horizontally does not affect the
@@ -66,7 +67,13 @@ function rasterize(edgeTable, backColor) {
 
     var layers = [];
     var color = 0;
+    
+    // Keeps track of how many of the subpixellayers that are used for 
+    // the currently rendered scanline. Until a range requiring supersampling
+    // is encountered only a single layer is needed.
+    var usedLayers = 0;
 
+    // Create a layer manager for every subpixel scanline
     for (var i = 0; i < SAMPLES_PER_PIXEL_Y; i++) {
         layers[i] = new LayerManager();
     }
@@ -78,45 +85,124 @@ function rasterize(edgeTable, backColor) {
             continue;
         }
 
-        for (var i = 0; i < layers.length; i++) {
+        for (var i = 0; i < usedLayers; i++) {
             layers[i].clear();
         }
+        usedLayers = 1;
 
         var superSampleRanges = getSuperSampleRanges(scanline, edgeTable.width);
 
         writer.skip(superSampleRanges[0].fromX);
 
         for (var rangeIndex = 0; rangeIndex < superSampleRanges.length; rangeIndex++) {
             var superSampleRange = superSampleRanges[rangeIndex];
+            
+            // If there is exactly one edge in the supersample range, and it is crossing
+            // the entire scanline, we can perform the antialiasing by integrating the
+            // edge function.
+            if (superSampleRange.edges.length == 1 && (
+                superSampleRange.edges[0].y0 <= ey && superSampleRange.edges[0].y1 >= ey + 1 ||
+                superSampleRange.edges[0].y0 >= ey + 1 && superSampleRange.edges[0].y1 <= ey
+                )) {
+                var edge = superSampleRange.edges[0];
+
+                // Determine the lower and upper x value where the edge 
+                // intersects the scanline.
+                var xey = edge.intersection(ey);
+                var xey1 = edge.intersection(ey + 1);
+                var x0 = Math.min(xey, xey1);
+                var x1 = Math.max(xey, xey1);
+                var width = x1 - x0;
+
+                // Compute the average color of all subpixel layers before
+                // and after the edge intersection.
+                for (var sy = 0; sy < usedLayers; sy++) {
+                    var subScanlineLayers = layers[sy];
+                    superSampleBuffer.add(subScanlineLayers.color, 1);
+                    subScanlineLayers.add(edge);
+                    superSampleBuffer.add(subScanlineLayers.color, 2);
+                    superSampleBuffer.rewind();
+                }
 
-            var y = ey + SAMPLE_HEIGHT / 2;
-
-            for (var sy = 0; sy < SAMPLES_PER_PIXEL_Y; sy++ , y += SAMPLE_HEIGHT) {
-                var subScanlineLayers = layers[sy];
-                color = subScanlineLayers.color;
+                var fromColor = superSampleBuffer.getColorAt(0);
+                color = superSampleBuffer.getColorAt(1);
+                
+                superSampleBuffer.clear();
+
+                // Render pixels
+                for (var x = superSampleRange.fromX; x < superSampleRange.toXExcl; x++) {
+                    if (x0 >= x + 1) {
+                        // Pixel not covered
+                        writer.write(fromColor, 1);
+                        continue;
+                    }
+
+                    if (x1 <= x) {
+                        // Pixel fully covered
+                        writer.write(color, 1);
+                        continue;
+                    }
+                    
+                    // toColor coverage in the range [0.0, 1.0]
+                    // Initialize to the fully covered range of the pixel.
+                    var coverage = x1 < x + 1 ? x + 1 - x1 : 0;
+
+                    // Compute integral for non-vertical edges
+                    if (width > 0.001) {
+                        // Range to integrate
+                        var integralFrom = Math.max(x0, x);
+                        var integralTo = Math.min(x1, x + 1);
+
+                        coverage += 
+                            (
+                                (integralTo * integralTo - integralFrom * integralFrom) / 2 +
+                                x0 * (integralFrom - integralTo)
+                            ) / width;
+                    }
+
+                    writer.write(colorUtils.mix(fromColor, color, coverage), 1);
+                }
 
-                var intersections = getIntersections(superSampleRange.edges, y);
+            } // /simplified antialiasing
+            else {
+                // There are more than a single intersecting edge in this range.
+                // Use super sampling to render the pixels.
+                var y = ey + SAMPLE_HEIGHT / 2;
+                
+                // Ensure all subpixel layers are initialized
+                while (usedLayers < SAMPLES_PER_PIXEL_Y) {
+                    layers[0].copyTo(layers[usedLayers]);
+                    usedLayers++;
+                }
 
-                for (var i = 0; i < intersections.length; i++) {
-                    var intersection = intersections[i];
-                    superSampleBuffer.add(color, intersection.x - superSampleRange.fromX);
-                    subScanlineLayers.add(intersection.edge);
+                // Average color of the pixels following the current supersample range.
+                for (var sy = 0; sy < SAMPLES_PER_PIXEL_Y; sy++ , y += SAMPLE_HEIGHT) {
+                    var subScanlineLayers = layers[sy];
                     color = subScanlineLayers.color;
-                }
 
-                // Write an extra pixel that will contain the color that
-                // will be forwarded until the next supersample range.
-                superSampleBuffer.add(color, superSampleRange.width + 1);
-                superSampleBuffer.rewind();
-            } // /subpixel
+                    var intersections = getIntersections(superSampleRange.edges, y);
+
+                    for (var i = 0; i < intersections.length; i++) {
+                        var intersection = intersections[i];
+                        superSampleBuffer.add(color, intersection.x - superSampleRange.fromX);
+                        subScanlineLayers.add(intersection.edge);
+                        color = subScanlineLayers.color;
+                    }
+
+                    // Write an extra pixel that will contain the color that
+                    // will be forwarded until the next supersample range.
+                    superSampleBuffer.add(color, superSampleRange.width + 1);
+                    superSampleBuffer.rewind();
+                } // /subpixel
+                
+                // Get color to be forwarded
+                color = superSampleBuffer.getColorAt(superSampleRange.width);
+
+                // Blend subpixels
+                superSampleBuffer.writeTo(writer, superSampleRange.width);
+                superSampleBuffer.clear();
+            }
 
-            // Get color to be forwarded
-            color = superSampleBuffer.getColorAt(superSampleRange.width);
-
-            // Blend subpixels
-            superSampleBuffer.writeTo(writer, superSampleRange.width);
-            superSampleBuffer.clear();
-
             // Forward last color
             if (rangeIndex + 1 < superSampleRanges.length) {
                 var nextRangeX = superSampleRanges[rangeIndex + 1].fromX;
@@ -172,7 +258,6 @@ function getIntersections(edges, y) {
 function getSuperSampleRanges(scanline, width) {
     var superSampleRanges = [];
 
-    const ALLOWED_RANGE_DISTANCE = 1;
     var rangeIndex = 0;
     var superSampleRangeIndex = 0;
 
@@ -192,7 +277,7 @@ function getSuperSampleRanges(scanline, width) {
         rangeIndex++;
 
         for (var i = rangeIndex; i < scanline.length; i++) {
-            if (scanline[i].fromX <= superSampleRange.toXExcl + ALLOWED_RANGE_DISTANCE) {
+            if (scanline[i].fromX < superSampleRange.toXExcl) {
                 superSampleRange.toXExcl = Math.max(superSampleRange.toXExcl, scanline[i].fromX + scanline[i].width);
                 superSampleRange.edges.push(scanline[i].edge);
                 rangeIndex++;