|
/* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for |
|
* full list of contributors). 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" |
|
}); |
|
|