261 lines
7.0 KiB
JavaScript
261 lines
7.0 KiB
JavaScript
goog.provide('ol.geom.Geometry');
|
|
goog.provide('ol.geom.GeometryLayout');
|
|
goog.provide('ol.geom.GeometryType');
|
|
|
|
goog.require('goog.asserts');
|
|
goog.require('goog.functions');
|
|
goog.require('ol.Object');
|
|
goog.require('ol.extent');
|
|
goog.require('ol.proj');
|
|
goog.require('ol.proj.Units');
|
|
|
|
|
|
/**
|
|
* The geometry type. One of `'Point'`, `'LineString'`, `'LinearRing'`,
|
|
* `'Polygon'`, `'MultiPoint'`, `'MultiLineString'`, `'MultiPolygon'`,
|
|
* `'GeometryCollection'`, `'Circle'`.
|
|
* @enum {string}
|
|
* @api stable
|
|
*/
|
|
ol.geom.GeometryType = {
|
|
POINT: 'Point',
|
|
LINE_STRING: 'LineString',
|
|
LINEAR_RING: 'LinearRing',
|
|
POLYGON: 'Polygon',
|
|
MULTI_POINT: 'MultiPoint',
|
|
MULTI_LINE_STRING: 'MultiLineString',
|
|
MULTI_POLYGON: 'MultiPolygon',
|
|
GEOMETRY_COLLECTION: 'GeometryCollection',
|
|
CIRCLE: 'Circle'
|
|
};
|
|
|
|
|
|
/**
|
|
* The coordinate layout for geometries, indicating whether a 3rd or 4th z ('Z')
|
|
* or measure ('M') coordinate is available. Supported values are `'XY'`,
|
|
* `'XYZ'`, `'XYM'`, `'XYZM'`.
|
|
* @enum {string}
|
|
* @api stable
|
|
*/
|
|
ol.geom.GeometryLayout = {
|
|
XY: 'XY',
|
|
XYZ: 'XYZ',
|
|
XYM: 'XYM',
|
|
XYZM: 'XYZM'
|
|
};
|
|
|
|
|
|
/**
|
|
* @classdesc
|
|
* Abstract base class; normally only used for creating subclasses and not
|
|
* instantiated in apps.
|
|
* Base class for vector geometries.
|
|
*
|
|
* To get notified of changes to the geometry, register a listener for the
|
|
* generic `change` event on your geometry instance.
|
|
*
|
|
* @constructor
|
|
* @extends {ol.Object}
|
|
* @api stable
|
|
*/
|
|
ol.geom.Geometry = function() {
|
|
|
|
goog.base(this);
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.Extent}
|
|
*/
|
|
this.extent_ = ol.extent.createEmpty();
|
|
|
|
/**
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
this.extentRevision_ = -1;
|
|
|
|
/**
|
|
* @protected
|
|
* @type {Object.<string, ol.geom.Geometry>}
|
|
*/
|
|
this.simplifiedGeometryCache = {};
|
|
|
|
/**
|
|
* @protected
|
|
* @type {number}
|
|
*/
|
|
this.simplifiedGeometryMaxMinSquaredTolerance = 0;
|
|
|
|
/**
|
|
* @protected
|
|
* @type {number}
|
|
*/
|
|
this.simplifiedGeometryRevision = 0;
|
|
|
|
};
|
|
goog.inherits(ol.geom.Geometry, ol.Object);
|
|
|
|
|
|
/**
|
|
* Make a complete copy of the geometry.
|
|
* @function
|
|
* @return {!ol.geom.Geometry} Clone.
|
|
*/
|
|
ol.geom.Geometry.prototype.clone = goog.abstractMethod;
|
|
|
|
|
|
/**
|
|
* @param {number} x X.
|
|
* @param {number} y Y.
|
|
* @param {ol.Coordinate} closestPoint Closest point.
|
|
* @param {number} minSquaredDistance Minimum squared distance.
|
|
* @return {number} Minimum squared distance.
|
|
*/
|
|
ol.geom.Geometry.prototype.closestPointXY = goog.abstractMethod;
|
|
|
|
|
|
/**
|
|
* Return the closest point of the geometry to the passed point as
|
|
* {@link ol.Coordinate coordinate}.
|
|
* @param {ol.Coordinate} point Point.
|
|
* @param {ol.Coordinate=} opt_closestPoint Closest point.
|
|
* @return {ol.Coordinate} Closest point.
|
|
* @api stable
|
|
*/
|
|
ol.geom.Geometry.prototype.getClosestPoint = function(point, opt_closestPoint) {
|
|
var closestPoint = opt_closestPoint ? opt_closestPoint : [NaN, NaN];
|
|
this.closestPointXY(point[0], point[1], closestPoint, Infinity);
|
|
return closestPoint;
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {ol.Coordinate} coordinate Coordinate.
|
|
* @return {boolean} Contains coordinate.
|
|
*/
|
|
ol.geom.Geometry.prototype.containsCoordinate = function(coordinate) {
|
|
return this.containsXY(coordinate[0], coordinate[1]);
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {ol.Extent} extent Extent.
|
|
* @protected
|
|
* @return {ol.Extent} extent Extent.
|
|
*/
|
|
ol.geom.Geometry.prototype.computeExtent = goog.abstractMethod;
|
|
|
|
|
|
/**
|
|
* @param {number} x X.
|
|
* @param {number} y Y.
|
|
* @return {boolean} Contains (x, y).
|
|
*/
|
|
ol.geom.Geometry.prototype.containsXY = goog.functions.FALSE;
|
|
|
|
|
|
/**
|
|
* Get the extent of the geometry.
|
|
* @param {ol.Extent=} opt_extent Extent.
|
|
* @return {ol.Extent} extent Extent.
|
|
* @api stable
|
|
*/
|
|
ol.geom.Geometry.prototype.getExtent = function(opt_extent) {
|
|
if (this.extentRevision_ != this.getRevision()) {
|
|
this.extent_ = this.computeExtent(this.extent_);
|
|
this.extentRevision_ = this.getRevision();
|
|
}
|
|
return ol.extent.returnOrUpdate(this.extent_, opt_extent);
|
|
};
|
|
|
|
|
|
/**
|
|
* Create a simplified version of this geometry. For linestrings, this uses
|
|
* the the {@link
|
|
* https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
|
|
* Douglas Peucker} algorithm. For polygons, a quantization-based
|
|
* simplification is used to preserve topology.
|
|
* @function
|
|
* @param {number} tolerance The tolerance distance for simplification.
|
|
* @return {ol.geom.Geometry} A new, simplified version of the original
|
|
* geometry.
|
|
* @api
|
|
*/
|
|
ol.geom.Geometry.prototype.simplify = function(tolerance) {
|
|
return this.getSimplifiedGeometry(tolerance * tolerance);
|
|
};
|
|
|
|
|
|
/**
|
|
* Create a simplified version of this geometry using the Douglas Peucker
|
|
* algorithm.
|
|
* @see https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
|
|
* @function
|
|
* @param {number} squaredTolerance Squared tolerance.
|
|
* @return {ol.geom.Geometry} Simplified geometry.
|
|
*/
|
|
ol.geom.Geometry.prototype.getSimplifiedGeometry = goog.abstractMethod;
|
|
|
|
|
|
/**
|
|
* Get the type of this geometry.
|
|
* @function
|
|
* @return {ol.geom.GeometryType} Geometry type.
|
|
*/
|
|
ol.geom.Geometry.prototype.getType = goog.abstractMethod;
|
|
|
|
|
|
/**
|
|
* Apply a transform function to each coordinate of the geometry.
|
|
* The geometry is modified in place.
|
|
* If you do not want the geometry modified in place, first clone() it and
|
|
* then use this function on the clone.
|
|
* @function
|
|
* @param {ol.TransformFunction} transformFn Transform.
|
|
*/
|
|
ol.geom.Geometry.prototype.applyTransform = goog.abstractMethod;
|
|
|
|
|
|
/**
|
|
* Test if the geometry and the passed extent intersect.
|
|
* @param {ol.Extent} extent Extent.
|
|
* @return {boolean} `true` if the geometry and the extent intersect.
|
|
* @function
|
|
*/
|
|
ol.geom.Geometry.prototype.intersectsExtent = goog.abstractMethod;
|
|
|
|
|
|
/**
|
|
* Translate the geometry. This modifies the geometry coordinates in place. If
|
|
* instead you want a new geometry, first `clone()` this geometry.
|
|
* @param {number} deltaX Delta X.
|
|
* @param {number} deltaY Delta Y.
|
|
* @function
|
|
*/
|
|
ol.geom.Geometry.prototype.translate = goog.abstractMethod;
|
|
|
|
|
|
/**
|
|
* Transform each coordinate of the geometry from one coordinate reference
|
|
* system to another. The geometry is modified in place.
|
|
* For example, a line will be transformed to a line and a circle to a circle.
|
|
* If you do not want the geometry modified in place, first clone() it and
|
|
* then use this function on the clone.
|
|
*
|
|
* @param {ol.proj.ProjectionLike} source The current projection. Can be a
|
|
* string identifier or a {@link ol.proj.Projection} object.
|
|
* @param {ol.proj.ProjectionLike} destination The desired projection. Can be a
|
|
* string identifier or a {@link ol.proj.Projection} object.
|
|
* @return {ol.geom.Geometry} This geometry. Note that original geometry is
|
|
* modified in place.
|
|
* @api stable
|
|
*/
|
|
ol.geom.Geometry.prototype.transform = function(source, destination) {
|
|
goog.asserts.assert(
|
|
ol.proj.get(source).getUnits() !== ol.proj.Units.TILE_PIXELS &&
|
|
ol.proj.get(destination).getUnits() !== ol.proj.Units.TILE_PIXELS,
|
|
'cannot transform geometries with TILE_PIXELS units');
|
|
this.applyTransform(ol.proj.getTransform(source, destination));
|
|
return this;
|
|
};
|