cc2e19d789
geometries. Thanks crschmidt for the great help with this patch, and thanks to camptocamp for the initial work on this and rcoup for creating the first patches. r=crschmidt (closes #1895) git-svn-id: http://svn.openlayers.org/trunk/openlayers@9262 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
283 lines
8.6 KiB
JavaScript
283 lines
8.6 KiB
JavaScript
/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
|
|
* license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the
|
|
* full text of the license. */
|
|
|
|
/**
|
|
* @requires OpenLayers/Geometry.js
|
|
*/
|
|
|
|
/**
|
|
* Class: OpenLayers.Geometry.Point
|
|
* Point geometry class.
|
|
*
|
|
* Inherits from:
|
|
* - <OpenLayers.Geometry>
|
|
*/
|
|
OpenLayers.Geometry.Point = OpenLayers.Class(OpenLayers.Geometry, {
|
|
|
|
/**
|
|
* APIProperty: x
|
|
* {float}
|
|
*/
|
|
x: null,
|
|
|
|
/**
|
|
* APIProperty: y
|
|
* {float}
|
|
*/
|
|
y: null,
|
|
|
|
/**
|
|
* Constructor: OpenLayers.Geometry.Point
|
|
* Construct a point geometry.
|
|
*
|
|
* Parameters:
|
|
* x - {float}
|
|
* y - {float}
|
|
*
|
|
*/
|
|
initialize: function(x, y) {
|
|
OpenLayers.Geometry.prototype.initialize.apply(this, arguments);
|
|
|
|
this.x = parseFloat(x);
|
|
this.y = parseFloat(y);
|
|
},
|
|
|
|
/**
|
|
* APIMethod: clone
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Geometry.Point>} An exact clone of this OpenLayers.Geometry.Point
|
|
*/
|
|
clone: function(obj) {
|
|
if (obj == null) {
|
|
obj = new OpenLayers.Geometry.Point(this.x, this.y);
|
|
}
|
|
|
|
// catch any randomly tagged-on properties
|
|
OpenLayers.Util.applyDefaults(obj, this);
|
|
|
|
return obj;
|
|
},
|
|
|
|
/**
|
|
* Method: calculateBounds
|
|
* Create a new Bounds based on the lon/lat
|
|
*/
|
|
calculateBounds: function () {
|
|
this.bounds = new OpenLayers.Bounds(this.x, this.y,
|
|
this.x, this.y);
|
|
},
|
|
|
|
/**
|
|
* 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 distance, x0, y0, x1, y1, result;
|
|
if(geometry instanceof OpenLayers.Geometry.Point) {
|
|
x0 = this.x;
|
|
y0 = this.y;
|
|
x1 = geometry.x;
|
|
y1 = geometry.y;
|
|
distance = Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));
|
|
result = !details ?
|
|
distance : {x0: x0, y0: y0, x1: x1, y1: y1, distance: distance};
|
|
} else {
|
|
result = geometry.distanceTo(this, options);
|
|
if(details) {
|
|
// switch coord order since this geom is target
|
|
result = {
|
|
x0: result.x1, y0: result.y1,
|
|
x1: result.x0, y1: result.y0,
|
|
distance: result.distance
|
|
};
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: equals
|
|
* Determine whether another geometry is equivalent to this one. Geometries
|
|
* are considered equivalent if all components have the same coordinates.
|
|
*
|
|
* Parameters:
|
|
* geom - {<OpenLayers.Geometry.Point>} The geometry to test.
|
|
*
|
|
* Returns:
|
|
* {Boolean} The supplied geometry is equivalent to this geometry.
|
|
*/
|
|
equals: function(geom) {
|
|
var equals = false;
|
|
if (geom != null) {
|
|
equals = ((this.x == geom.x && this.y == geom.y) ||
|
|
(isNaN(this.x) && isNaN(this.y) && isNaN(geom.x) && isNaN(geom.y)));
|
|
}
|
|
return equals;
|
|
},
|
|
|
|
/**
|
|
* Method: toShortString
|
|
*
|
|
* Returns:
|
|
* {String} Shortened String representation of Point object.
|
|
* (ex. <i>"5, 42"</i>)
|
|
*/
|
|
toShortString: function() {
|
|
return (this.x + ", " + this.y);
|
|
},
|
|
|
|
/**
|
|
* APIMethod: move
|
|
* Moves a geometry by the given displacement along positive x and y axes.
|
|
* This modifies the position of the geometry and clears the cached
|
|
* bounds.
|
|
*
|
|
* Parameters:
|
|
* x - {Float} Distance to move geometry in positive x direction.
|
|
* y - {Float} Distance to move geometry in positive y direction.
|
|
*/
|
|
move: function(x, y) {
|
|
this.x = this.x + x;
|
|
this.y = this.y + y;
|
|
this.clearBounds();
|
|
},
|
|
|
|
/**
|
|
* APIMethod: rotate
|
|
* Rotate a point around another.
|
|
*
|
|
* Parameters:
|
|
* angle - {Float} Rotation angle in degrees (measured counterclockwise
|
|
* from the positive x-axis)
|
|
* origin - {<OpenLayers.Geometry.Point>} Center point for the rotation
|
|
*/
|
|
rotate: function(angle, origin) {
|
|
angle *= Math.PI / 180;
|
|
var radius = this.distanceTo(origin);
|
|
var theta = angle + Math.atan2(this.y - origin.y, this.x - origin.x);
|
|
this.x = origin.x + (radius * Math.cos(theta));
|
|
this.y = origin.y + (radius * Math.sin(theta));
|
|
this.clearBounds();
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getCentroid
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Geometry.Point>} The centroid of the collection
|
|
*/
|
|
getCentroid: function() {
|
|
return new OpenLayers.Geometry.Point(this.x, this.y);
|
|
},
|
|
|
|
/**
|
|
* APIMethod: resize
|
|
* Resize a point relative to some origin. For points, this has the effect
|
|
* of scaling a vector (from the origin to the point). This method is
|
|
* more useful on geometry collection subclasses.
|
|
*
|
|
* Parameters:
|
|
* scale - {Float} Ratio of the new distance from the origin to the old
|
|
* distance from the origin. A scale of 2 doubles the
|
|
* distance between the point and origin.
|
|
* origin - {<OpenLayers.Geometry.Point>} Point of origin for resizing
|
|
* ratio - {Float} Optional x:y ratio for resizing. Default ratio is 1.
|
|
*
|
|
* Returns:
|
|
* {OpenLayers.Geometry} - The current geometry.
|
|
*/
|
|
resize: function(scale, origin, ratio) {
|
|
ratio = (ratio == undefined) ? 1 : ratio;
|
|
this.x = origin.x + (scale * ratio * (this.x - origin.x));
|
|
this.y = origin.y + (scale * (this.y - origin.y));
|
|
this.clearBounds();
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: intersects
|
|
* Determine if the input geometry intersects this one.
|
|
*
|
|
* Parameters:
|
|
* geometry - {<OpenLayers.Geometry>} Any type of geometry.
|
|
*
|
|
* Returns:
|
|
* {Boolean} The input geometry intersects this one.
|
|
*/
|
|
intersects: function(geometry) {
|
|
var intersect = false;
|
|
if(geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
|
|
intersect = this.equals(geometry);
|
|
} else {
|
|
intersect = geometry.intersects(this);
|
|
}
|
|
return intersect;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: transform
|
|
* Translate the x,y properties of the point from source to dest.
|
|
*
|
|
* Parameters:
|
|
* source - {<OpenLayers.Projection>}
|
|
* dest - {<OpenLayers.Projection>}
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Geometry>}
|
|
*/
|
|
transform: function(source, dest) {
|
|
if ((source && dest)) {
|
|
OpenLayers.Projection.transform(
|
|
this, source, dest);
|
|
this.bounds = null;
|
|
}
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* 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) {
|
|
return [this];
|
|
},
|
|
|
|
CLASS_NAME: "OpenLayers.Geometry.Point"
|
|
});
|