+
+
+/**
+ * Function: OpenLayers.Geometry.LineString.geodesic
+ *
+ * Parameters:
+ * interpolate - {function(number): OpenLayers.Geometry.Point} Interpolate
+ * function.
+ * transform - {function(OpenLayers.Geometry.Point): OpenLayers.Geometry.Point}
+ * Transform from longitude/latitude to projected coordinates.
+ * squaredTolerance - {number} Squared tolerance.
+ *
+ * Returns:
+ * {OpenLayers.Geometry.LineString}
+ */
+OpenLayers.Geometry.LineString.geodesic =
+ function(interpolate, transform, squaredTolerance) {
+ // FIXME reduce garbage generation
+ // FIXME optimize stack operations
+
+ var components = [];
+
+ var geoA = interpolate(0);
+ var geoB = interpolate(1);
+
+ var a = transform(geoA);
+ var b = transform(geoB);
+
+ var geoStack = [geoB, geoA];
+ var stack = [b, a];
+ var fractionStack = [1, 0];
+
+ var fractions = {};
+
+ var maxIterations = 1e5;
+ var geoM, m, fracA, fracB, fracM, key;
+
+ while (--maxIterations > 0 && fractionStack.length > 0) {
+ // Pop the a coordinate off the stack
+ fracA = fractionStack.pop();
+ geoA = geoStack.pop();
+ a = stack.pop();
+ // Add the a coordinate if it has not been added yet
+ key = fracA.toString();
+ if (!(key in fractions)) {
+ components.push(a);
+ fractions[key] = true;
+ }
+ // Pop the b coordinate off the stack
+ fracB = fractionStack.pop();
+ geoB = geoStack.pop();
+ b = stack.pop();
+ // Find the m point between the a and b coordinates
+ fracM = (fracA + fracB) / 2;
+ geoM = interpolate(fracM);
+ m = transform(geoM);
+ if (OpenLayers.Geometry.distanceSquaredToSegment(m, {x1: a.x, y1: a.y,
+ x2: b.x, y2: b.y}).distance < squaredTolerance) {
+ // If the m point is sufficiently close to the straight line, then
+ // we discard it. Just use the b coordinate and move on to the next
+ // line segment.
+ components.push(b);
+ key = fracB.toString();
+ fractions[key] = true;
+ } else {
+ // Otherwise, we need to subdivide the current line segment.
+ // Split it into two and push the two line segments onto the stack.
+ fractionStack.push(fracB, fracM, fracM, fracA);
+ stack.push(b, m, m, a);
+ geoStack.push(geoB, geoM, geoM, geoA);
+ }
+ }
+
+ return new OpenLayers.Geometry.LineString(components);
+};
+
+
+/**
+ * Function: OpenLayers.Geometry.LineString.geodesicMeridian
+ * Generate a meridian (line at constant longitude).
+ *
+ * Parameters:
+ * lon - {number} Longitude.
+ * lat1 - {number} Latitude 1.
+ * lat2 - {number} Latitude 2.
+ * projection - {OpenLayers.Projection} Projection.
+ * squaredTolerance - {number} Squared tolerance.
+ *
+ * Returns:
+ * {OpenLayers.Geometry.LineString} Line geometry for the meridian at <lon>.
+ */
+OpenLayers.Geometry.LineString.geodesicMeridian =
+ function(lon, lat1, lat2, projection, squaredTolerance) {
+ var epsg4326Projection = new OpenLayers.Projection('EPSG:4326');
+ return OpenLayers.Geometry.LineString.geodesic(
+ function(frac) {
+ return new OpenLayers.Geometry.Point(
+ lon, lat1 + ((lat2 - lat1) * frac));
+ },
+ function(point) {
+ return point.transform(epsg4326Projection, projection);
+ },
+ squaredTolerance
+ );
+};
+
+
+/**
+ * Function: OpenLayers.Geometry.LineString.geodesicParallel
+ * Generate a parallel (line at constant latitude).
+ *
+ * Parameters:
+ * lat - {number} Latitude.
+ * lon1 - {number} Longitude 1.
+ * lon2 - {number} Longitude 2.
+ * projection {OpenLayers.Projection} Projection.
+ * squaredTolerance - {number} Squared tolerance.
+ *
+ * Returns:
+ * {OpenLayers.Geometry.LineString} Line geometry for the parallel at <lat>.
+ */
+OpenLayers.Geometry.LineString.geodesicParallel =
+ function(lat, lon1, lon2, projection, squaredTolerance) {
+ var epsg4326Projection = new OpenLayers.Projection('EPSG:4326');
+ return OpenLayers.Geometry.LineString.geodesic(
+ function(frac) {
+ return new OpenLayers.Geometry.Point(
+ lon1 + ((lon2 - lon1) * frac), lat);
+ },
+ function(point) {
+ return point.transform(epsg4326Projection, projection);
+ },
+ squaredTolerance
+ );
+};
+
+/* ======================================================================
+ OpenLayers/Geometry/MultiLineString.js
+ ====================================================================== */
+
+/* Copyright (c) 2006-2015 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/Collection.js
+ * @requires OpenLayers/Geometry/LineString.js
+ */
+
+/**
+ * Class: OpenLayers.Geometry.MultiLineString
+ * A MultiLineString is a geometry with multiple <OpenLayers.Geometry.LineString>
+ * components.
+ *
+ * Inherits from:
+ * - <OpenLayers.Geometry.Collection>
+ * - <OpenLayers.Geometry>
+ */
+OpenLayers.Geometry.MultiLineString = OpenLayers.Class(
+ OpenLayers.Geometry.Collection, {
+
+ /**
+ * Property: componentTypes
+ * {Array(String)} An array of class names representing the types of
+ * components that the collection can include. A null value means the
+ * component types are not restricted.
+ */
+ componentTypes: ["OpenLayers.Geometry.LineString"],
+
+ /**
+ * Constructor: OpenLayers.Geometry.MultiLineString
+ * Constructor for a MultiLineString Geometry.
+ *
+ * Parameters:
+ * components - {Array(<OpenLayers.Geometry.LineString>)}
+ *
+ */
+
+ /**
+ * Method: split
+ * Use this geometry (the source) to attempt to split a target geometry.
+ *
+ * Parameters:
+ * geometry - {<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(geometry, options) {
+ var results = null;
+ var mutual = options && options.mutual;
+ var splits, sourceLine, sourceLines, sourceSplit, targetSplit;
+ var sourceParts = [];
+ var targetParts = [geometry];
+ for(var i=0, len=this.components.length; i<len; ++i) {
+ sourceLine = this.components[i];
+ sourceSplit = false;
+ for(var j=0; j < targetParts.length; ++j) {
+ splits = sourceLine.split(targetParts[j], options);
+ if(splits) {
+ if(mutual) {
+ sourceLines = splits[0];
+ for(var k=0, klen=sourceLines.length; k<klen; ++k) {
+ if(k===0 && sourceParts.length) {
+ sourceParts[sourceParts.length-1].addComponent(
+ sourceLines[k]
+ );
+ } else {
+ sourceParts.push(
+ new OpenLayers.Geometry.MultiLineString([
+ sourceLines[k]
+ ])
+ );
+ }
+ }
+ sourceSplit = true;
+ splits = splits[1];
+ }
+ if(splits.length) {
+ // splice in new target parts
+ splits.unshift(j, 1);
+ Array.prototype.splice.apply(targetParts, splits);
+ break;
+ }
+ }
+ }
+ if(!sourceSplit) {
+ // source line was not hit
+ if(sourceParts.length) {
+ // add line to existing multi
+ sourceParts[sourceParts.length-1].addComponent(
+ sourceLine.clone()
+ );
+ } else {
+ // create a fresh multi
+ sourceParts = [
+ new OpenLayers.Geometry.MultiLineString(
+ sourceLine.clone()
+ )
+ ];
+ }
+ }
+ }
+ if(sourceParts && sourceParts.length > 1) {
+ sourceSplit = true;
+ } else {
+ sourceParts = [];
+ }
+ if(targetParts && targetParts.length > 1) {
+ targetSplit = true;
+ } else {
+ targetParts = [];
+ }
+ if(sourceSplit || targetSplit) {
+ 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) {
+ var results = null;
+ var mutual = options && options.mutual;
+ var splits, targetLine, sourceLines, sourceSplit, targetSplit, sourceParts, targetParts;
+ if(geometry instanceof OpenLayers.Geometry.LineString) {
+ targetParts = [];
+ sourceParts = [geometry];
+ for(var i=0, len=this.components.length; i<len; ++i) {
+ targetSplit = false;
+ targetLine = this.components[i];
+ for(var j=0; j<sourceParts.length; ++j) {
+ splits = sourceParts[j].split(targetLine, options);
+ if(splits) {
+ if(mutual) {
+ sourceLines = splits[0];
+ if(sourceLines.length) {
+ // splice in new source parts
+ sourceLines.unshift(j, 1);
+ Array.prototype.splice.apply(sourceParts, sourceLines);
+ j += sourceLines.length - 2;
+ }
+ splits = splits[1];
+ if(splits.length === 0) {
+ splits = [targetLine.clone()];
+ }
+ }
+ for(var k=0, klen=splits.length; k<klen; ++k) {
+ if(k===0 && targetParts.length) {
+ targetParts[targetParts.length-1].addComponent(
+ splits[k]
+ );
+ } else {
+ targetParts.push(
+ new OpenLayers.Geometry.MultiLineString([
+ splits[k]
+ ])
+ );
+ }
+ }
+ targetSplit = true;
+ }
+ }
+ if(!targetSplit) {
+ // target component was not hit
+ if(targetParts.length) {
+ // add it to any existing multi-line
+ targetParts[targetParts.length-1].addComponent(
+ targetLine.clone()
+ );
+ } else {
+ // or start with a fresh multi-line
+ targetParts = [
+ new OpenLayers.Geometry.MultiLineString([
+ targetLine.clone()
+ ])
+ ];
+ }
+
+ }
+ }
+ } else {
+ results = geometry.split(this);
+ }
+ if(sourceParts && sourceParts.length > 1) {
+ sourceSplit = true;
+ } else {
+ sourceParts = [];
+ }
+ if(targetParts && targetParts.length > 1) {
+ targetSplit = true;
+ } else {
+ targetParts = [];
+ }
+ if(sourceSplit || targetSplit) {
+ if(mutual) {
+ results = [sourceParts, targetParts];
+ } else {
+ results = targetParts;
+ }
+ }
+ return results;
+ },
+
+ CLASS_NAME: "OpenLayers.Geometry.MultiLineString"
+});
ToastFreeware / philipp / winterrodeln / mediawiki_extensions / wrmap.git / blobdiff