More trip planner testing with colors
[busui.git] / labs / openlayers / lib / OpenLayers / Geometry / Point.js
blob:a/labs/openlayers/lib/OpenLayers/Geometry/Point.js -> blob:b/labs/openlayers/lib/OpenLayers/Geometry/Point.js
  /* 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"
  });