From 1cc885056bff010f064530bec7643b02cf72e3bd Mon Sep 17 00:00:00 2001 From: mourner Date: Fri, 3 Feb 2012 12:07:06 +0200 Subject: [PATCH] Significantly improved line simplification performance --- CHANGELOG.md | 1 + src/geometry/LineUtil.js | 115 +++++++++++++++++++++------------------ 2 files changed, 64 insertions(+), 52 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e2a9ee89..a7e0bafe 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,7 @@ Leaflet Changelog * Map now preserves its center after resize. * When panning to another copy of the world (that's infinite horizontally), map overlays now jump to corresponding positions. [#273](https://github.com/CloudMade/Leaflet/issues/273) * Limited maximum zoom change on a single mouse wheel movement (so you won't zoom across the whole zoom range in one scroll). [#149](https://github.com/CloudMade/Leaflet/issues/149) + * Significantly improved line simplification performance (noticeable when rendering polylines/polygons with tens of thousands of points) * Improved circles performance by not drawing them if they're off the clip region. #### API improvements diff --git a/src/geometry/LineUtil.js b/src/geometry/LineUtil.js index 21ccfd9e..ad0bded3 100644 --- a/src/geometry/LineUtil.js +++ b/src/geometry/LineUtil.js @@ -13,72 +13,80 @@ L.LineUtil = { return points.slice(); } + var sqTolerance = tolerance * tolerance; + // stage 1: vertex reduction - points = this.reducePoints(points, tolerance); + points = this._reducePoints(points, sqTolerance); // stage 2: Douglas-Peucker simplification - points = this.simplifyDP(points, tolerance); + points = this._simplifyDP(points, sqTolerance); return points; }, // distance from a point to a segment between two points pointToSegmentDistance: function (/*Point*/ p, /*Point*/ p1, /*Point*/ p2) { - return Math.sqrt(this._sqPointToSegmentDist(p, p1, p2)); + return Math.sqrt(this._sqClosestPointOnSegment(p, p1, p2, true)); }, closestPointOnSegment: function (/*Point*/ p, /*Point*/ p1, /*Point*/ p2) { - var point = this._sqClosestPointOnSegment(p, p1, p2); - point.distance = Math.sqrt(point._sqDist); - return point; + return this._sqClosestPointOnSegment(p, p1, p2); }, // Douglas-Peucker simplification, see http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm - simplifyDP: function (points, tol) { - var maxDist2 = 0, - index = 0, - t2 = tol * tol, - len = points.length, - i, dist2; + _simplifyDP: function (points, sqTolerance) { - if (len < 3) { - return points; - } + var len = points.length, + ArrayConstructor = typeof Uint8Array !== 'undefined' ? Uint8Array : Array, + markers = new ArrayConstructor(len); - for (i = 0; i < len - 1; i++) { - dist2 = this._sqPointToSegmentDist(points[i], points[0], points[len - 1]); - if (dist2 > maxDist2) { - index = i; - maxDist2 = dist2; + markers[0] = markers[len - 1] = 1; + + this._simplifyDPStep(points, markers, sqTolerance, 0, len - 1); + + var i, + newPoints = []; + + for (i = 0; i < len; i++) { + if (markers[i]) { + newPoints.push(points[i]); } } - var part1, part2; + return newPoints; + }, - if (maxDist2 >= t2) { - part1 = points.slice(0, index); - part2 = points.slice(index); + _simplifyDPStep: function (points, markers, sqTolerance, first, last) { - part1 = this.simplifyDP(part1, tol); - part2 = this.simplifyDP(part2, tol); + var maxSqDist = 0, + index, i, sqDist; - return part1.concat(part2); - } else { - return [points[0], points[len - 1]]; + for (i = first + 1; i <= last - 1; i++) { + sqDist = this._sqClosestPointOnSegment(points[i], points[first], points[last], true); + + if (sqDist > maxSqDist) { + index = i; + maxSqDist = sqDist; + } + } + + if (maxSqDist > sqTolerance) { + markers[index] = 1; + + this._simplifyDPStep(points, markers, sqTolerance, first, index); + this._simplifyDPStep(points, markers, sqTolerance, index, last); } }, // reduce points that are too close to each other to a single point - reducePoints: function (points, tol) { - var reducedPoints = [points[0]], - t2 = tol * tol; + _reducePoints: function (points, sqTolerance) { + var reducedPoints = [points[0]]; for (var i = 1, prev = 0, len = points.length; i < len; i++) { - if (this._sqDist(points[i], points[prev]) < t2) { - continue; + if (this._sqDist(points[i], points[prev]) > sqTolerance) { + reducedPoints.push(points[i]); + prev = i; } - reducedPoints.push(points[i]); - prev = i; } if (prev < len - 1) { reducedPoints.push(points[len - 1]); @@ -168,27 +176,30 @@ L.LineUtil = { return dx * dx + dy * dy; }, - // return closest point on segment with attribute _sqDist - square distance to segment - _sqClosestPointOnSegment: function (p, p1, p2) { - var x2 = p2.x - p1.x, - y2 = p2.y - p1.y, - apoint = p1; - if (x2 || y2) { - var dot = (p.x - p1.x) * x2 + (p.y - p1.y) * y2, - t = dot / this._sqDist(p1, p2); + // return closest point on segment or distance to that point + _sqClosestPointOnSegment: function (p, p1, p2, sqDist) { + var x = p1.x, + y = p1.y, + dx = p2.x - x, + dy = p2.y - y, + dot = dx * dx + dy * dy, + t; + + if (dot > 0) { + t = ((p.x - x) * dx + (p.y - y) * dy) / dot; if (t > 1) { - apoint = p2; + x = p2.x; + y = p2.y; } else if (t > 0) { - apoint = new L.Point(p1.x + x2 * t, p1.y + y2 * t); + x += dx * t; + y += dy * t; } } - apoint._sqDist = this._sqDist(p, apoint); - return apoint; - }, - // distance from a point to a segment between two points - _sqPointToSegmentDist: function (p, p1, p2) { - return this._sqClosestPointOnSegment(p, p1, p2)._sqDist; + dx = p.x - x; + dy = p.y - y; + + return sqDist ? dx * dx + dy * dy : new L.Point(x, y); } };