Upgrading openlayers to 3.x

1 files changed, 0 insertions, 646 deletions

diff --git a/misc/openlayers/lib/OpenLayers/Geometry/LineString.js b/misc/openlayers/lib/OpenLayers/Geometry/LineString.js
deleted file mode 100644
index b7d7dac..0000000
--- a/misc/openlayers/lib/OpenLayers/Geometry/LineString.js
+++ /dev/null
@@ -1,646 +0,0 @@
-/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for
- * full list of contributors). Published under the 2-clause BSD license.
- * See license.txt in the OpenLayers distribution or repository for the
- * full text of the license. */
-
-/**
- * @requires OpenLayers/Geometry/Curve.js
- */
-
-/**
- * Class: OpenLayers.Geometry.LineString
- * A LineString is a Curve which, once two points have been added to it, can 
- * never be less than two points long.
- * 
- * Inherits from:
- *  - <OpenLayers.Geometry.Curve>
- */
-OpenLayers.Geometry.LineString = OpenLayers.Class(OpenLayers.Geometry.Curve, {
-
-    /**
-     * Constructor: OpenLayers.Geometry.LineString
-     * Create a new LineString geometry
-     *
-     * Parameters:
-     * points - {Array(<OpenLayers.Geometry.Point>)} An array of points used to
-     *          generate the linestring
-     *
-     */
-
-    /**
-     * APIMethod: removeComponent
-     * Only allows removal of a point if there are three or more points in 
-     * the linestring. (otherwise the result would be just a single point)
-     *
-     * Parameters: 
-     * point - {<OpenLayers.Geometry.Point>} The point to be removed
-     *
-     * Returns: 
-     * {Boolean} The component was removed.
-     */
-    removeComponent: function(point) {
-        var removed = this.components && (this.components.length > 2);
-        if (removed) {
-            OpenLayers.Geometry.Collection.prototype.removeComponent.apply(this, 
-                                                                  arguments);
-        }
-        return removed;
-    },
-    
-    /**
-     * APIMethod: intersects
-     * Test for instersection between two geometries.  This is a cheapo
-     *     implementation of the Bently-Ottmann algorigithm.  It doesn't
-     *     really keep track of a sweep line data structure.  It is closer
-     *     to the brute force method, except that segments are sorted and
-     *     potential intersections are only calculated when bounding boxes
-     *     intersect.
-     *
-     * Parameters:
-     * geometry - {<OpenLayers.Geometry>}
-     *
-     * Returns:
-     * {Boolean} The input geometry intersects this geometry.
-     */
-    intersects: function(geometry) {
-        var intersect = false;
-        var type = geometry.CLASS_NAME;
-        if(type == "OpenLayers.Geometry.LineString" ||
-           type == "OpenLayers.Geometry.LinearRing" ||
-           type == "OpenLayers.Geometry.Point") {
-            var segs1 = this.getSortedSegments();
-            var segs2;
-            if(type == "OpenLayers.Geometry.Point") {
-                segs2 = [{
-                    x1: geometry.x, y1: geometry.y,
-                    x2: geometry.x, y2: geometry.y
-                }];
-            } else {
-                segs2 = geometry.getSortedSegments();
-            }
-            var seg1, seg1x1, seg1x2, seg1y1, seg1y2,
-                seg2, seg2y1, seg2y2;
-            // sweep right
-            outer: for(var i=0, len=segs1.length; i<len; ++i) {
-                seg1 = segs1[i];
-                seg1x1 = seg1.x1;
-                seg1x2 = seg1.x2;
-                seg1y1 = seg1.y1;
-                seg1y2 = seg1.y2;
-                inner: for(var j=0, jlen=segs2.length; j<jlen; ++j) {
-                    seg2 = segs2[j];
-                    if(seg2.x1 > seg1x2) {
-                        // seg1 still left of seg2
-                        break;
-                    }
-                    if(seg2.x2 < seg1x1) {
-                        // seg2 still left of seg1
-                        continue;
-                    }
-                    seg2y1 = seg2.y1;
-                    seg2y2 = seg2.y2;
-                    if(Math.min(seg2y1, seg2y2) > Math.max(seg1y1, seg1y2)) {
-                        // seg2 above seg1
-                        continue;
-                    }
-                    if(Math.max(seg2y1, seg2y2) < Math.min(seg1y1, seg1y2)) {
-                        // seg2 below seg1
-                        continue;
-                    }
-                    if(OpenLayers.Geometry.segmentsIntersect(seg1, seg2)) {
-                        intersect = true;
-                        break outer;
-                    }
-                }
-            }
-        } else {
-            intersect = geometry.intersects(this);
-        }
-        return intersect;
-    },
-    
-    /**
-     * Method: getSortedSegments
-     *
-     * Returns:
-     * {Array} An array of segment objects.  Segment objects have properties
-     *     x1, y1, x2, and y2.  The start point is represented by x1 and y1.
-     *     The end point is represented by x2 and y2.  Start and end are
-     *     ordered so that x1 < x2.
-     */
-    getSortedSegments: function() {
-        var numSeg = this.components.length - 1;
-        var segments = new Array(numSeg), point1, point2;
-        for(var i=0; i<numSeg; ++i) {
-            point1 = this.components[i];
-            point2 = this.components[i + 1];
-            if(point1.x < point2.x) {
-                segments[i] = {
-                    x1: point1.x,
-                    y1: point1.y,
-                    x2: point2.x,
-                    y2: point2.y
-                };
-            } else {
-                segments[i] = {
-                    x1: point2.x,
-                    y1: point2.y,
-                    x2: point1.x,
-                    y2: point1.y
-                };
-            }
-        }
-        // more efficient to define this somewhere static
-        function byX1(seg1, seg2) {
-            return seg1.x1 - seg2.x1;
-        }
-        return segments.sort(byX1);
-    },
-    
-    /**
-     * Method: splitWithSegment
-     * Split this geometry with the given segment.
-     *
-     * Parameters:
-     * seg - {Object} An object with x1, y1, x2, and y2 properties referencing
-     *     segment endpoint coordinates.
-     * options - {Object} Properties of this object will be used to determine
-     *     how the split is conducted.
-     *
-     * Valid options:
-     * edge - {Boolean} Allow splitting when only edges intersect.  Default is
-     *     true.  If false, a vertex on the source segment must be within the
-     *     tolerance distance of the intersection to be considered a split.
-     * tolerance - {Number} If a non-null value is provided, intersections
-     *     within the tolerance distance of one of the source segment's
-     *     endpoints will be assumed to occur at the endpoint.
-     *
-     * Returns:
-     * {Object} An object with *lines* and *points* properties.  If the given
-     *     segment intersects this linestring, the lines array will reference
-     *     geometries that result from the split.  The points array will contain
-     *     all intersection points.  Intersection points are sorted along the
-     *     segment (in order from x1,y1 to x2,y2).
-     */
-    splitWithSegment: function(seg, options) {
-        var edge = !(options && options.edge === false);
-        var tolerance = options && options.tolerance;
-        var lines = [];
-        var verts = this.getVertices();
-        var points = [];
-        var intersections = [];
-        var split = false;
-        var vert1, vert2, point;
-        var node, vertex, target;
-        var interOptions = {point: true, tolerance: tolerance};
-        var result = null;
-        for(var i=0, stop=verts.length-2; i<=stop; ++i) {
-            vert1 = verts[i];
-            points.push(vert1.clone());
-            vert2 = verts[i+1];
-            target = {x1: vert1.x, y1: vert1.y, x2: vert2.x, y2: vert2.y};
-            point = OpenLayers.Geometry.segmentsIntersect(
-                seg, target, interOptions
-            );
-            if(point instanceof OpenLayers.Geometry.Point) {
-                if((point.x === seg.x1 && point.y === seg.y1) ||
-                   (point.x === seg.x2 && point.y === seg.y2) ||
-                   point.equals(vert1) || point.equals(vert2)) {
-                    vertex = true;
-                } else {
-                    vertex = false;
-                }
-                if(vertex || edge) {
-                    // push intersections different than the previous
-                    if(!point.equals(intersections[intersections.length-1])) {
-                        intersections.push(point.clone());
-                    }
-                    if(i === 0) {
-                        if(point.equals(vert1)) {
-                            continue;
-                        }
-                    }
-                    if(point.equals(vert2)) {
-                        continue;
-                    }
-                    split = true;
-                    if(!point.equals(vert1)) {
-                        points.push(point);
-                    }
-                    lines.push(new OpenLayers.Geometry.LineString(points));
-                    points = [point.clone()];
-                }
-            }
-        }
-        if(split) {
-            points.push(vert2.clone());
-            lines.push(new OpenLayers.Geometry.LineString(points));
-        }
-        if(intersections.length > 0) {
-            // sort intersections along segment
-            var xDir = seg.x1 < seg.x2 ? 1 : -1;
-            var yDir = seg.y1 < seg.y2 ? 1 : -1;
-            result = {
-                lines: lines,
-                points: intersections.sort(function(p1, p2) {
-                    return (xDir * p1.x - xDir * p2.x) || (yDir * p1.y - yDir * p2.y);
-                })
-            };
-        }
-        return result;
-    },
-
-    /**
-     * Method: split
-     * Use this geometry (the source) to attempt to split a target geometry.
-     * 
-     * Parameters:
-     * target - {<OpenLayers.Geometry>} The target geometry.
-     * options - {Object} Properties of this object will be used to determine
-     *     how the split is conducted.
-     *
-     * Valid options:
-     * mutual - {Boolean} Split the source geometry in addition to the target
-     *     geometry.  Default is false.
-     * edge - {Boolean} Allow splitting when only edges intersect.  Default is
-     *     true.  If false, a vertex on the source must be within the tolerance
-     *     distance of the intersection to be considered a split.
-     * tolerance - {Number} If a non-null value is provided, intersections
-     *     within the tolerance distance of an existing vertex on the source
-     *     will be assumed to occur at the vertex.
-     * 
-     * Returns:
-     * {Array} A list of geometries (of this same type as the target) that
-     *     result from splitting the target with the source geometry.  The
-     *     source and target geometry will remain unmodified.  If no split
-     *     results, null will be returned.  If mutual is true and a split
-     *     results, return will be an array of two arrays - the first will be
-     *     all geometries that result from splitting the source geometry and
-     *     the second will be all geometries that result from splitting the
-     *     target geometry.
-     */
-    split: function(target, options) {
-        var results = null;
-        var mutual = options && options.mutual;
-        var sourceSplit, targetSplit, sourceParts, targetParts;
-        if(target instanceof OpenLayers.Geometry.LineString) {
-            var verts = this.getVertices();
-            var vert1, vert2, seg, splits, lines, point;
-            var points = [];
-            sourceParts = [];
-            for(var i=0, stop=verts.length-2; i<=stop; ++i) {
-                vert1 = verts[i];
-                vert2 = verts[i+1];
-                seg = {
-                    x1: vert1.x, y1: vert1.y,
-                    x2: vert2.x, y2: vert2.y
-                };
-                targetParts = targetParts || [target];
-                if(mutual) {
-                    points.push(vert1.clone());
-                }
-                for(var j=0; j<targetParts.length; ++j) {
-                    splits = targetParts[j].splitWithSegment(seg, options);
-                    if(splits) {
-                        // splice in new features
-                        lines = splits.lines;
-                        if(lines.length > 0) {
-                            lines.unshift(j, 1);
-                            Array.prototype.splice.apply(targetParts, lines);
-                            j += lines.length - 2;
-                        }
-                        if(mutual) {
-                            for(var k=0, len=splits.points.length; k<len; ++k) {
-                                point = splits.points[k];
-                                if(!point.equals(vert1)) {
-                                    points.push(point);
-                                    sourceParts.push(new OpenLayers.Geometry.LineString(points));
-                                    if(point.equals(vert2)) {
-                                        points = [];
-                                    } else {
-                                        points = [point.clone()];
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            if(mutual && sourceParts.length > 0 && points.length > 0) {
-                points.push(vert2.clone());
-                sourceParts.push(new OpenLayers.Geometry.LineString(points));
-            }
-        } else {
-            results = target.splitWith(this, options);
-        }
-        if(targetParts && targetParts.length > 1) {
-            targetSplit = true;
-        } else {
-            targetParts = [];
-        }
-        if(sourceParts && sourceParts.length > 1) {
-            sourceSplit = true;
-        } else {
-            sourceParts = [];
-        }
-        if(targetSplit || sourceSplit) {
-            if(mutual) {
-                results = [sourceParts, targetParts];
-            } else {
-                results = targetParts;
-            }
-        }
-        return results;
-    },
-
-    /**
-     * Method: splitWith
-     * Split this geometry (the target) with the given geometry (the source).
-     *
-     * Parameters:
-     * geometry - {<OpenLayers.Geometry>} A geometry used to split this
-     *     geometry (the source).
-     * options - {Object} Properties of this object will be used to determine
-     *     how the split is conducted.
-     *
-     * Valid options:
-     * mutual - {Boolean} Split the source geometry in addition to the target
-     *     geometry.  Default is false.
-     * edge - {Boolean} Allow splitting when only edges intersect.  Default is
-     *     true.  If false, a vertex on the source must be within the tolerance
-     *     distance of the intersection to be considered a split.
-     * tolerance - {Number} If a non-null value is provided, intersections
-     *     within the tolerance distance of an existing vertex on the source
-     *     will be assumed to occur at the vertex.
-     * 
-     * Returns:
-     * {Array} A list of geometries (of this same type as the target) that
-     *     result from splitting the target with the source geometry.  The
-     *     source and target geometry will remain unmodified.  If no split
-     *     results, null will be returned.  If mutual is true and a split
-     *     results, return will be an array of two arrays - the first will be
-     *     all geometries that result from splitting the source geometry and
-     *     the second will be all geometries that result from splitting the
-     *     target geometry.
-     */
-    splitWith: function(geometry, options) {
-        return geometry.split(this, options);
-
-    },
-
-    /**
-     * APIMethod: getVertices
-     * Return a list of all points in this geometry.
-     *
-     * Parameters:
-     * nodes - {Boolean} For lines, only return vertices that are
-     *     endpoints.  If false, for lines, only vertices that are not
-     *     endpoints will be returned.  If not provided, all vertices will
-     *     be returned.
-     *
-     * Returns:
-     * {Array} A list of all vertices in the geometry.
-     */
-    getVertices: function(nodes) {
-        var vertices;
-        if(nodes === true) {
-            vertices = [
-                this.components[0],
-                this.components[this.components.length-1]
-            ];
-        } else if (nodes === false) {
-            vertices = this.components.slice(1, this.components.length-1);
-        } else {
-            vertices = this.components.slice();
-        }
-        return vertices;
-    },
-
-    /**
-     * APIMethod: distanceTo
-     * Calculate the closest distance between two geometries (on the x-y plane).
-     *
-     * Parameters:
-     * geometry - {<OpenLayers.Geometry>} The target geometry.
-     * options - {Object} Optional properties for configuring the distance
-     *     calculation.
-     *
-     * Valid options:
-     * details - {Boolean} Return details from the distance calculation.
-     *     Default is false.
-     * edge - {Boolean} Calculate the distance from this geometry to the
-     *     nearest edge of the target geometry.  Default is true.  If true,
-     *     calling distanceTo from a geometry that is wholly contained within
-     *     the target will result in a non-zero distance.  If false, whenever
-     *     geometries intersect, calling distanceTo will return 0.  If false,
-     *     details cannot be returned.
-     *
-     * Returns:
-     * {Number | Object} The distance between this geometry and the target.
-     *     If details is true, the return will be an object with distance,
-     *     x0, y0, x1, and x2 properties.  The x0 and y0 properties represent
-     *     the coordinates of the closest point on this geometry. The x1 and y1
-     *     properties represent the coordinates of the closest point on the
-     *     target geometry.
-     */
-    distanceTo: function(geometry, options) {
-        var edge = !(options && options.edge === false);
-        var details = edge && options && options.details;
-        var result, best = {};
-        var min = Number.POSITIVE_INFINITY;
-        if(geometry instanceof OpenLayers.Geometry.Point) {
-            var segs = this.getSortedSegments();
-            var x = geometry.x;
-            var y = geometry.y;
-            var seg;
-            for(var i=0, len=segs.length; i<len; ++i) {
-                seg = segs[i];
-                result = OpenLayers.Geometry.distanceToSegment(geometry, seg);
-                if(result.distance < min) {
-                    min = result.distance;
-                    best = result;
-                    if(min === 0) {
-                        break;
-                    }
-                } else {
-                    // if distance increases and we cross y0 to the right of x0, no need to keep looking.
-                    if(seg.x2 > x && ((y > seg.y1 && y < seg.y2) || (y < seg.y1 && y > seg.y2))) {
-                        break;
-                    }
-                }
-            }
-            if(details) {
-                best = {
-                    distance: best.distance,
-                    x0: best.x, y0: best.y,
-                    x1: x, y1: y
-                };
-            } else {
-                best = best.distance;
-            }
-        } else if(geometry instanceof OpenLayers.Geometry.LineString) { 
-            var segs0 = this.getSortedSegments();
-            var segs1 = geometry.getSortedSegments();
-            var seg0, seg1, intersection, x0, y0;
-            var len1 = segs1.length;
-            var interOptions = {point: true};
-            outer: for(var i=0, len=segs0.length; i<len; ++i) {
-                seg0 = segs0[i];
-                x0 = seg0.x1;
-                y0 = seg0.y1;
-                for(var j=0; j<len1; ++j) {
-                    seg1 = segs1[j];
-                    intersection = OpenLayers.Geometry.segmentsIntersect(seg0, seg1, interOptions);
-                    if(intersection) {
-                        min = 0;
-                        best = {
-                            distance: 0,
-                            x0: intersection.x, y0: intersection.y,
-                            x1: intersection.x, y1: intersection.y
-                        };
-                        break outer;
-                    } else {
-                        result = OpenLayers.Geometry.distanceToSegment({x: x0, y: y0}, seg1);
-                        if(result.distance < min) {
-                            min = result.distance;
-                            best = {
-                                distance: min,
-                                x0: x0, y0: y0,
-                                x1: result.x, y1: result.y
-                            };
-                        }
-                    }
-                }
-            }
-            if(!details) {
-                best = best.distance;
-            }
-            if(min !== 0) {
-                // check the final vertex in this line's sorted segments
-                if(seg0) {
-                    result = geometry.distanceTo(
-                        new OpenLayers.Geometry.Point(seg0.x2, seg0.y2),
-                        options
-                    );
-                    var dist = details ? result.distance : result;
-                    if(dist < min) {
-                        if(details) {
-                            best = {
-                                distance: min,
-                                x0: result.x1, y0: result.y1,
-                                x1: result.x0, y1: result.y0
-                            };
-                        } else {
-                            best = dist;
-                        }
-                    }
-                }
-            }
-        } else {
-            best = geometry.distanceTo(this, options);
-            // swap since target comes from this line
-            if(details) {
-                best = {
-                    distance: best.distance,
-                    x0: best.x1, y0: best.y1,
-                    x1: best.x0, y1: best.y0
-                };
-            }
-        }
-        return best;
-    },
-    
-    /**
-     * APIMethod: simplify
-     * This function will return a simplified LineString.
-     * Simplification is based on the Douglas-Peucker algorithm.
-     *
-     *
-     * Parameters:
-     * tolerance - {number} threshhold for simplification in map units
-     *
-     * Returns:
-     * {OpenLayers.Geometry.LineString} the simplified LineString
-     */
-    simplify: function(tolerance){
-        if (this && this !== null) {
-            var points = this.getVertices();
-            if (points.length < 3) {
-                return this;
-            }
-    
-            var compareNumbers = function(a, b){
-                return (a-b);
-            };
-    
-            /**
-             * Private function doing the Douglas-Peucker reduction
-             */
-            var douglasPeuckerReduction = function(points, firstPoint, lastPoint, tolerance){
-                var maxDistance = 0;
-                var indexFarthest = 0;
-    
-                for (var index = firstPoint, distance; index < lastPoint; index++) {
-                    distance = perpendicularDistance(points[firstPoint], points[lastPoint], points[index]);
-                    if (distance > maxDistance) {
-                        maxDistance = distance;
-                        indexFarthest = index;
-                    }
-                }
-    
-                if (maxDistance > tolerance && indexFarthest != firstPoint) {
-                    //Add the largest point that exceeds the tolerance
-                    pointIndexsToKeep.push(indexFarthest);
-                    douglasPeuckerReduction(points, firstPoint, indexFarthest, tolerance);
-                    douglasPeuckerReduction(points, indexFarthest, lastPoint, tolerance);
-                }
-            };
-    
-            /**
-             * Private function calculating the perpendicular distance
-             * TODO: check whether OpenLayers.Geometry.LineString::distanceTo() is faster or slower
-             */
-            var perpendicularDistance = function(point1, point2, point){
-                //Area = |(1/2)(x1y2 + x2y3 + x3y1 - x2y1 - x3y2 - x1y3)|   *Area of triangle
-                //Base = v((x1-x2)²+(x1-x2)²)                               *Base of Triangle*
-                //Area = .5*Base*H                                          *Solve for height
-                //Height = Area/.5/Base
-    
-                var area = Math.abs(0.5 * (point1.x * point2.y + point2.x * point.y + point.x * point1.y - point2.x * point1.y - point.x * point2.y - point1.x * point.y));
-                var bottom = Math.sqrt(Math.pow(point1.x - point2.x, 2) + Math.pow(point1.y - point2.y, 2));
-                var height = area / bottom * 2;
-    
-                return height;
-            };
-    
-            var firstPoint = 0;
-            var lastPoint = points.length - 1;
-            var pointIndexsToKeep = [];
-    
-            //Add the first and last index to the keepers
-            pointIndexsToKeep.push(firstPoint);
-            pointIndexsToKeep.push(lastPoint);
-    
-            //The first and the last point cannot be the same
-            while (points[firstPoint].equals(points[lastPoint])) {
-                lastPoint--;
-                //Addition: the first point not equal to first point in the LineString is kept as well
-                pointIndexsToKeep.push(lastPoint);
-            }
-    
-            douglasPeuckerReduction(points, firstPoint, lastPoint, tolerance);
-            var returnPoints = [];
-            pointIndexsToKeep.sort(compareNumbers);
-            for (var index = 0; index < pointIndexsToKeep.length; index++) {
-                returnPoints.push(points[pointIndexsToKeep[index]]);
-            }
-            return new OpenLayers.Geometry.LineString(returnPoints);
-    
-        }
-        else {
-            return this;
-        }
-    },
-
-    CLASS_NAME: "OpenLayers.Geometry.LineString"
-});