mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
537 lines
29 KiB
TypeScript
537 lines
29 KiB
TypeScript
// Type definitions for Microsoft.Maps 8.0 (Change set e6d7cc4)
|
||
// Project: https://github.com/Microsoft/Bing-Maps-V8-TypeScript-Definitions
|
||
// Definitions by: Ricky Brundritt <https://github.com/rbrundritt>
|
||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||
|
||
/// <reference path="Microsoft.Maps.d.ts"/>
|
||
|
||
//////////////////////////////////////////////
|
||
/// Core Library
|
||
//////////////////////////////////////////////
|
||
|
||
/**
|
||
* This module provides a bunch of useful spatial math calculations.
|
||
* @requires The Microsoft.Maps.SpatialMath module.
|
||
*/
|
||
declare module Microsoft.Maps.SpatialMath {
|
||
|
||
/**
|
||
* Distance Unit enumerator
|
||
* @requires The Microsoft.Maps.SpatialMath module.
|
||
**/
|
||
export enum DistanceUnits {
|
||
/** A distance in meters */
|
||
Meters,
|
||
|
||
/** A distance in kilometers */
|
||
Kilometers,
|
||
|
||
/** A distance in miles */
|
||
Miles,
|
||
|
||
/** A distance in Feet */
|
||
Feet,
|
||
|
||
/** A distance in Yards */
|
||
Yards,
|
||
|
||
/** A distance in Nautical Miles */
|
||
NauticalMiles
|
||
}
|
||
|
||
/**
|
||
* Area units enumerator
|
||
* @requires The Microsoft.Maps.SpatialMath module.
|
||
**/
|
||
export enum AreaUnits {
|
||
/** Area in square meters */
|
||
SquareMeters,
|
||
|
||
/** Area in square kilometers */
|
||
SquareKilometers,
|
||
|
||
/** Area in square miles */
|
||
SquareMiles,
|
||
|
||
/** Area in square Feet */
|
||
SquareFeet,
|
||
|
||
/** Area in square Yards */
|
||
SquareYards,
|
||
|
||
/** Area in Acres */
|
||
Acres,
|
||
|
||
/** Area in Hectares */
|
||
Hectares
|
||
}
|
||
|
||
//////////////////////////////////////////////
|
||
/// Core Calculations
|
||
//////////////////////////////////////////////
|
||
|
||
/**
|
||
* Converts an area from one area units to another.
|
||
* @param area A number that represents an area to convert.
|
||
* @param fromUnits The area units the original area is in.
|
||
* @param toUnits The area units to convert to.
|
||
* @returns An area in the new units.
|
||
**/
|
||
export function convertArea(area: number, fromUnits: AreaUnits, toUnits: AreaUnits): number;
|
||
|
||
/**
|
||
* Converts a distance from one distance units to another.
|
||
* @param distance A number that represents a distance to convert.
|
||
* @param fromUnits The distance units the original distance is in.
|
||
* @param toUnits The disired distance units to convert to.
|
||
* @returns A distance in the new units.
|
||
**/
|
||
export function convertDistance(distance: number, fromUnits: DistanceUnits, toUnits: DistanceUnits): number;
|
||
|
||
/**
|
||
* Calculates an array of locations that form a cardinal spline between the specified array of locations.
|
||
* @param locations The array of locations to calculate the spline through.
|
||
* @param tension A number that indicates the tightness of the curve. Can be any number, although a value between 0 and 1 is usually used. Default: 0.5
|
||
* @param nodeSize Number of nodes to insert between each Location. Default: 15
|
||
* @param close A boolean indicating if the spline should be a closed ring or not. Default: false
|
||
* @returns An array of locations that form a cardinal spline between the specified array of locations.
|
||
*/
|
||
export function getCardinalSpline(locations: Location[], tension ?: number, nodeSize ?: number, close ?: boolean): Location[];
|
||
|
||
/**
|
||
* Calculates a destination Location based on a starting Location, a heading, a distance, and a distance unit type.
|
||
* @param origin Location that the destination is relative to.
|
||
* @param bearing A heading angle between 0 - 360 degrees. 0 - North, 90 - East, 180 - South, 270 - West.
|
||
* @param distance Distance that destination is away.
|
||
* @param units Unit of distance measurement. Default is Meters.
|
||
* @returns A Location that is the specified distance away from the origin.
|
||
**/
|
||
export function getDestination(origin: Location, bearing: number, distance: number, units?: DistanceUnits): Location;
|
||
|
||
/**
|
||
* Calculate the distance between two Location objects on the surface of the earth using the Haversine formula.
|
||
* @param origin First Location to calculate distance between.
|
||
* @param destination Second Location to calculate distance between.
|
||
* @param units Unit of distance measurement. Default is Meters.
|
||
* @param highAccuracy When set enabled, will use the slower but more accurate Vincenty formula for calculating distances, rather than the Haversine formula.
|
||
* @returns The shortest distance between two Locations in the specifed units.
|
||
**/
|
||
export function getDistanceTo(origin: Location, destination: Location, units?: DistanceUnits, highAccuracy?: boolean): number;
|
||
|
||
/**
|
||
* Retrieves the radius of the earth in a specific distance unit for WGS84.
|
||
* @param units Unit of distance measurement. Default: Meters
|
||
* @returns A number that represents the radius of the earth in a specific distance unit.
|
||
**/
|
||
export function getEarthRadius(units?: DistanceUnits): number;
|
||
|
||
/**
|
||
* Takes an array of Locations objects and fills in the space between them with accurately positioned Locations to form an approximated Geodesic path.
|
||
* @param path Array of Location objects that form a path to fill in.
|
||
* @param nodeSize Number of nodes to insert between each Location. Default: 15
|
||
* @returns An array of Location objects that form a geodesic paths.
|
||
**/
|
||
export function getGeodesicPath(path: Location[], nodeSize?: number): Location[];
|
||
|
||
/**
|
||
* Calculates the heading from one Location object to another.
|
||
* @param origin Point of origin.
|
||
* @param destination Destination to calculate relative heading to.
|
||
* @returns A heading in degrees between 0 and 360. 0 degrees points due North.
|
||
**/
|
||
export function getHeading(origin: Location, destination: Location): number;
|
||
|
||
/**
|
||
* Calculates the distance between all Location objects in an array.
|
||
* @param path The array of Location objects that make up the path to calculate the length of.
|
||
* @param units Unit of distance measurement. Default: Meters
|
||
* @param highAccuracy If set to true, uses the more accurate Vincenty algorithm for calcuating distances. Otherwise the faster Haversine formula is used.
|
||
* @returns The distance between all Locations in between all Location objects in an array on the surface of a earth in the specifed units.
|
||
**/
|
||
export function getLengthOfPath(path: Location[], units?: DistanceUnits, highAccuracy?: boolean): number;
|
||
|
||
/**
|
||
* Calculates the Location object on a path that is a specified distance away from the start of the path. If the specified distance is longer
|
||
* than the length of the path, the last Location of the path will be returned.
|
||
* @param path A polyline or array of Location coordinates that form a path.
|
||
* @param distance The distance along the path (from the start) to calculate the location for.
|
||
* @param units Unit of distance measurement. Default is Meters.
|
||
* @returns A Location object that is the specified distance away from the start of the path when following the path.
|
||
**/
|
||
export function getLocationAlongPath(path: Polyline | Location[], distance: number, units?: DistanceUnits): Location;
|
||
|
||
/**
|
||
* Calculates an array of Location objects that are an equal distance away from a central point to create a regular polygon.
|
||
* @param origin Center of the regular polygon.
|
||
* @param radius Radius of the regular polygon.
|
||
* @param numberOfPoints Number of points the polygon should have.
|
||
* @param units Unit of distance measurement for radius. Default is Meters.
|
||
* @param offset An offset to rotate the polygon clockwise in degrees. When 0 the first Location will align with North.
|
||
* @returns An array of Location objects that form a regular polygon.
|
||
**/
|
||
export function getRegularPolygon(origin: Location, radius: number, numberOfPoints: number, units?: DistanceUnits, offset?: number): Location[];
|
||
|
||
/**
|
||
* Calculates a Location object that is a fractional distance between two Location objects.
|
||
* @param origin First Location to calculate mid-point between.
|
||
* @param destination Second Location to calculate mid-point between.
|
||
* @param fraction The fractional parameter to calculate a mid-point for. Default 0.5.
|
||
* @returns A Location that lies a fraction of the distance between two Location objects, relative to the first Location object.
|
||
**/
|
||
export function interpolate(origin: Location, destination: Location, fraction?: number): Location;
|
||
|
||
/**
|
||
* Takes a LocationRect and converts it to a polygon.
|
||
* @param bounds The LocationRect to convert to a Polygon.
|
||
* @returns A polygon representation of the LocationRect.
|
||
**/
|
||
export function locationRectToPolygon(bounds: LocationRect): Polygon;
|
||
|
||
/**
|
||
* Takes a Location object and converts it into a Degree Minute Seconds string in the format. For example: 40° 26′ 46″ N 79° 58′ 56″ W
|
||
* @param loc The Location object to convert into a Degree Minute Seconds string.
|
||
* @returns A string in Degree Minute Seconds format or null if invalid Location object is provided.
|
||
*/
|
||
export function toDegMinSec(loc: Location): string;
|
||
|
||
/**
|
||
* Tries to parse the given string that is in Degree Minute Seconds format. For Example: 35° 26′ 31″ E or 40° 26′ 46″ N 79° 58′ 56″ W
|
||
* @param input A string in Degree Minute Seconds format to parse.
|
||
* @returns Returns a decimal degree value if only a single angle is provided. If two angles provided in the string, then a
|
||
* Location object is returned. If string is in an invalid format, null is returned.
|
||
*/
|
||
export function tryParseDegMinSec(input: string): number | Location;
|
||
}
|
||
|
||
|
||
//////////////////////////////////////////////
|
||
/// Tile Calculations
|
||
//////////////////////////////////////////////
|
||
|
||
/**
|
||
* A colleciton of mathematical algorithms based on the tile pyramid used by Bign Maps.
|
||
* @requires The Microsoft.Maps.SpatialMath module.
|
||
*/
|
||
declare module Microsoft.Maps.SpatialMath.Tiles {
|
||
//Based on https://msdn.microsoft.com/en-us/library/bb259689.aspx
|
||
|
||
/**
|
||
* Calculates the full width of the map in pixels at a specific zoom level from -180 degrees to 180 degrees.
|
||
* @param zoom Zoom level to calculate width at.
|
||
* @param tileWidth Width of tile.
|
||
* @returns Width of map in pixels.
|
||
**/
|
||
export function mapSize(zoom: number): number;
|
||
|
||
/**
|
||
* Calculates the Ground resolution at a specific degree of latitude in the specified units per pixel.
|
||
* @param latitude Degree of latitude to calculate resolution at.
|
||
* @param zoom Zoom level to calculate resolution at.
|
||
* @param units Distance unit type to calculate resolution in.
|
||
* @returns Ground resolution in distance unit per pixels.
|
||
**/
|
||
export function groundResolution(latitude: number, zoom: number, units?: SpatialMath.DistanceUnits): number;
|
||
|
||
/**
|
||
* Converts a Pixel coordinate into a Geospatial Location at a specified zoom level.
|
||
* Global Pixel coordinates are relative to the top left corner of the map (90, -180)
|
||
* @param point Pixel coordinate.
|
||
* @param zoom Zoom level.
|
||
* @returns A Location that is at the specified pixel location at a specified zoom level.
|
||
**/
|
||
export function globalPixelToLocation(point: Point, zoom: number): Location;
|
||
|
||
/**
|
||
* Converts a point from latitude/longitude WGS-84 Location (in degrees)
|
||
* into pixel XY coordinates at a specified level of detail.
|
||
* @param loc Location to convert to a global pixel.
|
||
* @param zoom Level of detail, from 1 (lowest detail) to 23 (highest detail).
|
||
* @returns Point object containing the the global pixel location of a Location.
|
||
**/
|
||
export function locationToGlobalPixel(loc: Location, zoom: number): Point;
|
||
|
||
/**
|
||
* Calculates the PyramidTileId that a global pixel intersects with at a specific zoom level.
|
||
* @param pixel The pixel coordinate to calculate the tile for.
|
||
* @param zoom The zoom level to calculate the tile for.
|
||
* @returns A PyramidTileId that a global pixel intersects with at a specific zoom level.
|
||
**/
|
||
export function globalPixelToTile(pixel: Point, zoom: number): PyramidTileId;
|
||
|
||
/**
|
||
* Converts a PyramidTileId into a global pixel coordinates of the upper-left pixel of the specified tile.
|
||
* @param tile A PyramidTileId to calculate the upper-left pixel for.
|
||
* @returns Global pixel coordinate of the top left corner of a tile.
|
||
**/
|
||
export function tileToGlobalPixel(tile: PyramidTileId): Point;
|
||
|
||
/**
|
||
* Calculates the PyramidTileId that a Location object intersects with at a specific zoom level.
|
||
* @param loc The location to calulate the tile for.
|
||
* @param zoom The zoom level to use to calculate the tile.
|
||
* @returns A PyramidTileId that a Location object intersects with at a specific zoom level.
|
||
**/
|
||
export function locationToTile(loc: Location, zoom: number): PyramidTileId;
|
||
|
||
/**
|
||
* Calculates all the PyramidTileId's that are within a LocationRect at a specific zoom level.
|
||
* @param bounds A LocationRect to search for tiles in.
|
||
* @param zoom The zoom level to calculate tiles for.
|
||
* @returns A list of PyramidTileId's that are within the specified LocationRect and zoom level.
|
||
**/
|
||
export function getTilesInBounds(bounds: LocationRect, zoom: number): PyramidTileId[];
|
||
|
||
/**
|
||
* Calculates the LocationRect (bounding box) of a PyramidTileId.
|
||
* @param tile A PyramidTileId to calculate the LocationRect of.
|
||
* @returns The bounding box of a tile.
|
||
**/
|
||
export function tileToLocationRect(tile: PyramidTileId): LocationRect;
|
||
}
|
||
|
||
|
||
//////////////////////////////////////////////
|
||
/// Geometry Calculations
|
||
//////////////////////////////////////////////
|
||
|
||
/**
|
||
* A colleciton of geometry calculations that can be performed against Bing Maps shapes.
|
||
* @requires The Microsoft.Maps.SpatialMath module.
|
||
*/
|
||
declare module Microsoft.Maps.SpatialMath.Geometry {
|
||
|
||
/** Defines how the end of a line should be buffered. */
|
||
export enum BufferEndCap {
|
||
/** Adds a rounded end to a buffered line. */
|
||
Round,
|
||
|
||
/** Adds a flat end to a buffered line that touches the end of the line. */
|
||
Flat,
|
||
|
||
/** Adds a square end to a buffered line that has a buffer area at the end of the line. */
|
||
Square
|
||
}
|
||
|
||
/**
|
||
* Calculates the area of a shape.
|
||
* @param shape The shape to calculate the area of.
|
||
* @param areaUnits The unit of measurement to calculate the area in.
|
||
* @returns The area of a shape in the specified unit of measurement.
|
||
*/
|
||
export function area(shape: IPrimitive | IPrimitive[], areaUnits?: AreaUnits): number;
|
||
|
||
/**
|
||
* Calculates a bounding box that encloses a set of shapes and/or locations.
|
||
* @param shapes The shape(s) to calculate the bounding box for.
|
||
* @returns A location rect that encloses the shapes and/or locations.
|
||
*/
|
||
export function bounds(shapes: Location | IPrimitive | (Location | IPrimitive)[]): LocationRect;
|
||
|
||
/**
|
||
* Calcuates a shape with an updated boundary that has been inflated/deflated by a speicifed distance.
|
||
* @param shape The shape to buffer.
|
||
* @param distance The distance to buffer the shape by.
|
||
* @param units The distance units to buffer the shape by.
|
||
* @param endCapType The type of end cap to use for the joints of the buffer, default value is round.
|
||
* @param options A set of polygon options to apply to the generated shape.
|
||
* @returns A buffered version of the shape.
|
||
*/
|
||
export function buffer(shape: Location | IPrimitive | (Location | IPrimitive)[], distance: number, units?: DistanceUnits, endCapType?: BufferEndCap, options?: IPolygonOptions): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Calculates the center of a shape.
|
||
* @param shape The shape to calculate the center of.
|
||
* @returns The center of the specified shape.
|
||
*/
|
||
export function centroid(shape: IPrimitive | IPrimitive[]): Location;
|
||
|
||
/**
|
||
* Calculates an approximate concave hull that best fits the data.
|
||
* A concave hull is a shape that represents that a possible concave geometry that encloses all shapes in the specified data set.
|
||
* If a single unique Location is in the data set, a Pushpin is returned. If only two unique Locations are provided, or if all Locations form a line, a Polyline is returned.
|
||
* If 3 or more unique Locations are in the data set a Polygon, or array of Polygons will be returned.
|
||
* @param shapes Shape(s) whose Location(s) or Location(s) are to be used to generate a concave hull.
|
||
* @param allowMultiPolygons A boolean indicating if the resulting concave hull can be a MultiPolygon. Default: false
|
||
* @param allowHoles A boolean indicating if the polygons in the resulting concave hull can have holes in them. Default: false
|
||
* @param options A set of polygon options to apply to the generated shape.
|
||
* @returns An approximate concave hull that best fits the data.
|
||
* If a single unique Location is in the data set, a Pushpin is returned. If only two unique Locations are provided, or if all Locations form a line, a Polyline is returned.
|
||
* If 3 or more unique Locations are in the data set a Polygon, or array of Polygons will be returned.
|
||
*/
|
||
export function concaveHull(shapes: Location | IPrimitive | (Location | IPrimitive)[], allowMultiPolygons?: boolean, allowHoles?: boolean, options?: IPolygonOptions): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Given two shapes, determines if the first one contains the second one
|
||
* (or, the second shape is a subset of the first shape) or not.
|
||
* @param shapeA The first shape to test against the second.
|
||
* @param shapeB The second shape to test against the first.
|
||
* @returns A boolean indicating if the first shape contains the second shape.
|
||
*/
|
||
export function contains(shapeA: Location | IPrimitive | (Location | IPrimitive)[], shapeB: Location | IPrimitive | (Location | IPrimitive)[]): boolean;
|
||
|
||
/**
|
||
* Calculates a convex hull. A convex hull is a shape that represents that minimum convex geometry that encloses all shapes in the specified data set.
|
||
* @param shapes Shape(s) whose Location(s) or Location(s) are to be used to generate a convex hull.
|
||
* @param options A set of polygon options to apply to the generated shape.
|
||
* @returns An array of locations that form a convex hull that encloses all locations of the shapes provided in an array.
|
||
*/
|
||
export function convexHull(shapes: Location | IPrimitive | (Location | IPrimitive)[], options?: IPolygonOptions): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Creates Delaunay Triangles from the Location objects of the provided shapes.
|
||
* @param shapes Location(s) of shape(s) or Location(s) to generate a Delaunay Triangles from.
|
||
* @param options A set of polyline or polygon options to apply to the generated shape.
|
||
* @returns An array of shapes that form the polygon triangles of the delaunay triangles.
|
||
*/
|
||
export function delaunayTriangles(shapes: Location | IPrimitive | (Location | IPrimitive)[], options?: IPolygonOptions): Polygon[];
|
||
|
||
/**
|
||
* Returns an object that represents area of an initial shape subtracted by the overlapping area of a second shape.
|
||
* @param shapeA The first shape.
|
||
* @param shapeB The second shape to subtract from the first.
|
||
* @returns A set of shapes that represent the area of the first shape that is not overlapped by the second shape.
|
||
*/
|
||
export function difference(shapeA: IPrimitive | IPrimitive[], shapeB: IPrimitive | IPrimitive[]): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Calculates the approximate shortest distance between any two shapes.
|
||
* @param shapeA The first shape to calculate the distance from.
|
||
* @param shapeB The second shape to calculate the distance to.
|
||
* @param units Unit of distance measurement. Default: Meters
|
||
* @param highAccuracy If set to true, uses the more accurate Vincenty algorithm for calcuating distances. Otherwise the faster Haversine formula is used.
|
||
* @returns The shorested distance between the shapes in the specified units.
|
||
*/
|
||
export function distance(shapeA: Location | IPrimitive | (Location | IPrimitive)[], shapeB: Location | IPrimitive | (Location | IPrimitive)[], units?: DistanceUnits, highAccuracy?: boolean): number;
|
||
|
||
/**
|
||
* Returns an object that represents the area where two shapes intersect.
|
||
* @param shapeA The first shape.
|
||
* @param shapeB The second shape.
|
||
* @returns A set of shapes that represents the area where two shapes intersect.
|
||
*/
|
||
export function intersection(shapeA: IPrimitive | IPrimitive[], shapeB: IPrimitive | IPrimitive[]): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Determines if two shapes intersect or not.
|
||
* @param shapeA The first shape to test against the second.
|
||
* @param shapeB The second shape to test against the first.
|
||
* @returns A boolean indicating if the two shapes intersect.
|
||
*/
|
||
export function intersects(shapeA: Location | IPrimitive | (Location | IPrimitive)[], shapeB: Location | IPrimitive | (Location | IPrimitive)[]): boolean;
|
||
|
||
/**
|
||
* Tests to see if the shape is valid and meets the requirements of an SQL Geography type and other OGC compliant systems. Polylines & Polygons can't be self intersecting. For Polygons,
|
||
* coordinates in an exterior rings have a counter-clockwise orientation, while holes have a clockwise orientation.
|
||
* @param shape The shape to test for validity.
|
||
* @returns Returns a boolean indicting if the specified shape(s) is valid or not.
|
||
*/
|
||
export function isValid(shape: IPrimitive | IPrimitive[]): boolean;
|
||
|
||
/**
|
||
* Calculates the distance between all Locations in a shape. If the shape is a polygon, the length of the perimeter of all rings is calculated.
|
||
* @param shape The shape to calculate the length of.
|
||
* @param units Unit of distance measurement. Default: Meters
|
||
* @param highAccuracy If set to true, uses the more accurate Vincenty algorithm for calcuating distances. Otherwise the faster Haversine formula is used.
|
||
* @returns The distance between all Locations in a polyline or the perimeter of a ploygon on the surface of a earth in the specifed units.
|
||
*/
|
||
export function calculateLength(shape: IPrimitive | IPrimitive[], units ?: DistanceUnits, highAccuracy ?: boolean): number;
|
||
|
||
/**
|
||
* Takes a shape and returns a copy of it that meets the requirements of an SQL Geography type and other OGC compliant systems. Polylines & Polygons can't be self intersecting. For Polygons,
|
||
* coordinates in an exterior rings have a counter-clockwise orientation, while holes have a clockwise orientation.
|
||
* @param shape The shape to make valid.
|
||
* @returns Valiated version of the provided shape. May be a different shape type than what was provided. i.e. A polygon may be broken up into an array of polygons (MultiPolygon).
|
||
*/
|
||
export function makeValid(shape: IPrimitive | IPrimitive[]): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Calculates the nearest Location objects between to shapes that lie on the shapes.
|
||
* If the shapes do not overlap, this calculates a location on each shape that is closest to the other shape.
|
||
* If the shapes overlap, a location that is within the intersection area of the shapes will be added twice to an array, once for each shape, and returned.
|
||
* @param shapeA The first shape.
|
||
* @param shapeB The second shape.
|
||
* @returns An array of two Location objects that represent the nearest points between two shapes.
|
||
* The Location objects are in the same order as the input shapes.
|
||
* Returns null if nearest points were unable to be computed.
|
||
*/
|
||
export function nearestLocations(shapeA: Location | IPrimitive | (Location | IPrimitive)[], shapeB: Location | IPrimitive | (Location | IPrimitive)[]): Location[];
|
||
|
||
/**
|
||
* Reduces the resolution of a shape using the Douglas-Peucker algorithm.
|
||
* @param shape The shape to reduce the resolution of.
|
||
* @param tolerance A tolerance distance in meters used by the reduction algorithms.
|
||
* @returns A version of the specified shape that has been reduced.
|
||
*/
|
||
export function reduce(shape: IPrimitive | IPrimitive[], tolerance: number): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Rotates a shape around a given Location for the specified angle of rotation. If an origin is not provided, the centroid of the shape is used.
|
||
* @param shape The shape to be rotated.
|
||
* @param angle The amount to rotate the shape in degrees.
|
||
* @param origin The location to rotate the shape around. Defaults to the centroid of the shape.
|
||
*/
|
||
export function rotate(shape: IPrimitive | IPrimitive[], angle: number, origin?: Location): void;
|
||
|
||
/**
|
||
* Calculates the shortest path that between two shapes and returns a Polyline.
|
||
* @param shapeA The first shape.
|
||
* @param shapeB The second shape.
|
||
* @param options A set of polyline options to apply to the generated polyline.
|
||
* @returns A polyline that represents the shortest path between two shapes.
|
||
*/
|
||
export function shortestLineTo(shapeA: Location | IPrimitive | (Location | IPrimitive)[], shapeB: Location | IPrimitive | (Location | IPrimitive)[], options?: IPolylineOptions): Polyline;
|
||
|
||
/**
|
||
* Snaps the locations of one shape that are within the specified tolerance distance away from another shape.
|
||
* @param locs The locations to snap to the shape.
|
||
* @param shape The shape to snap the locations to.
|
||
* @param tolerance A maximum distance (in the specified units) that the snapped location can be from the input location. Default: Infinity
|
||
* @param toleranceUnits The distance units of the tolerance value. Default: Meters
|
||
* @returns A snapped location if only one location is provided, otherwise returns an array of snapped locations.
|
||
*/
|
||
export function snapLocationsToShape(locs: Location | Location[], shape: IPrimitive | IPrimitive[], tolerance?: number, toleranceUnits?: DistanceUnits): Location | Location[];
|
||
|
||
/**
|
||
* Snaps the locations of one shape that are within the specified tolerance distance away from another shape.
|
||
* @param shapeToSnap The shape to snap the locations of.
|
||
* @param shape The shape to snap the locations to.
|
||
* @param tolerance A maximum distance (in the specified units) that the snapped location can be from the input location. Default: Infinity
|
||
* @param toleranceUnits The distance units of the tolerance value. Default: Meters
|
||
*/
|
||
export function snapShapeToShape(shapeToSnap: IPrimitive | IPrimitive[], shape: IPrimitive | IPrimitive[], tolerance?: number, toleranceUnits?: DistanceUnits): void;
|
||
|
||
/**
|
||
* Returns an object that represents all points that are either in one shape instance or another, but not those points that lie in both instances.
|
||
* "Sym" stands for Symmetric. symDifference is an OGC standard name for this calculation used in most spatial math libraries, including SQL.
|
||
* @param shapeA The first shape.
|
||
* @param shapeB The second shape.
|
||
* @returns A shape that represents the symetric difference between two shapes.
|
||
*/
|
||
export function symDifference(shapeA: IPrimitive | IPrimitive[], shapeB: IPrimitive | IPrimitive[]): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Returns an object that represents the union of two shapes. If shapes don't overlap, an array of each individual shapes will be returned.
|
||
* @param shapeA The first shape.
|
||
* @param shapeB The second shape.
|
||
* @returns A shape that represents the union of two shapes.
|
||
*/
|
||
export function union(shapeA: IPrimitive | IPrimitive[], shapeB: IPrimitive | IPrimitive[]): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Performs a union operation on a set of shapes.
|
||
* If a shape doesn't overlap with the rest, the returned result will be an array of shapes containing this shape and the union of the rest.
|
||
* @param shapes An array of shapes to union together.
|
||
* @returns A shape that represents the union of all specified shapes.
|
||
*/
|
||
export function unionAggregate(shapes: IPrimitive[]): IPrimitive | IPrimitive[];
|
||
|
||
/**
|
||
* Creates a Voronoi diagram from the Location objects of the provided shapes. The diagram is returned as an array of Polygons.
|
||
* If a clip region is specified, the diagram will be clipped accordingly.
|
||
* @param shapes Location(s) of shape(s) or Location(s) to generate a Voronoi diagram.
|
||
* @param clipRegion A region to clip the voronoi diagram to.
|
||
* @param options A set of polygon options to apply to the generated shape.
|
||
* @returns An array of polygons that form a Voronoi diagram.
|
||
*/
|
||
export function voronoiDiagram(shapes: Location | IPrimitive | (Location | IPrimitive)[], clipRegion?: LocationRect | Polygon, options?: IPolygonOptions): Polygon[];
|
||
} |