tg-map-vue3 3.9.8 → 3.9.9

package/CHANGELOG.md

@@ -4,6 +4,7 @@
 
 - ***BREAKING CHANGE***: 依赖[tg-commons](https://www.npmjs.com/package/tg-commons), 移除`typed`/`isDef`等和地图无关的导出
 - feat: [TgMarker]添加`label`属性, **它和已有的[TgLabel]不能同时设置**
+- feat: 添加球体和线段工具: [SphericalUtil], [PolyUtil]
 
 ## 3.8.x
 
@@ -87,3 +88,5 @@
 [LatLng]: src/map/lat-lng.ts#L26
 [BaiduShape]: src/map/map/overlay/shape.ts#L32
 [MapStyle]: src/map/map/map-options.ts#72
+[PolyUtil]: src/utils/maps-utils/poly-util.ts
+[SphericalUtil]: src/utils/maps-utils/spherical-util.ts

package/dist/src/components/index.d.ts

@@ -38,6 +38,7 @@ export * from '../map/map/overlay/rectangle';
 export * from '../map/types';
 export * from '../utils/arrays';
 export * from '../utils/mapped-types';
+export * from '../utils/maps-utils';
 export { Objects } from '../utils/objects';
 export * from '../utils/spherical-utils';
 export * from '../utils/strings';

package/dist/src/utils/maps-utils/index.d.ts

@@ -0,0 +1,2 @@
+export * as PolyUtil from './poly-util';
+export * as SphericalUtil from './spherical-util';

package/dist/src/utils/maps-utils/math-util.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The earth's radius, in meters.
+ * Mean radius as defined by IUGG.
+ */
+export declare const EARTH_RADIUS = 6371009;
+/**
+ * Restrict x to the range [low, high].
+ */
+export declare function clamp(x: number, low: number, high: number): number;
+/**
+ * Wraps the given value into the inclusive-exclusive interval between min and max.
+ *
+ * @param n The value to wrap.
+ * @param min The minimum.
+ * @param max The maximum.
+ */
+export declare function wrap(n: number, min: number, max: number): number;
+/**
+ * Returns the non-negative remainder of x / m.
+ *
+ * @param x The operand.
+ * @param m The modulus.
+ */
+export declare function mod(x: number, m: number): number;
+/**
+ * Returns mercator Y corresponding to latitude.
+ * See http://en.wikipedia.org/wiki/Mercator_projection .
+ */
+export declare function mercator(lat: number): number;
+/**
+ * Returns latitude from mercator Y.
+ */
+export declare function inverseMercator(y: number): number;
+/**
+ * Returns haversine(angle-in-radians).
+ * hav(x) == (1 - cos(x)) / 2 == sin(x / 2)^2.
+ */
+export declare function hav(x: number): number;
+/**
+ * Computes inverse haversine. Has good numerical stability around 0.
+ * arcHav(x) == acos(1 - 2 * x) == 2 * asin(sqrt(x)).
+ * The argument must be in [0, 1], and the result is positive.
+ */
+export declare function arcHav(x: number): number;
+export declare function sinFromHav(h: number): number;
+export declare function havFromSin(x: number): number;
+export declare function sinSumFromHav(x: number, y: number): number;
+/**
+ * Returns hav() of distance from (lat1, lng1) to (lat2, lng2) on the unit sphere.
+ */
+export declare function havDistance(lat1: number, lat2: number, dLng: number): number;
+/**
+ * Converts degrees to radians.
+ */
+export declare function toRadians(degrees: number): number;
+/**
+ * Converts radians to degrees.
+ */
+export declare function toDegrees(radians: number): number;

package/dist/src/utils/maps-utils/poly-util.d.ts

@@ -0,0 +1,103 @@
+import type { LatLngLiteral } from '../../map/lat-lng';
+export declare function containsLocation(point: LatLngLiteral, polygon: LatLngLiteral[], geodesic: boolean): boolean;
+/**
+ * Computes whether the given point lies inside the specified polygon.
+ * The polygon is always considered closed, regardless of whether the last point equals
+ * the first or not.
+ * Inside is defined as not containing the South Pole -- the South Pole is always outside.
+ * The polygon is formed of great circle segments if geodesic is true, and of rhumb
+ * (loxodromic) segments otherwise.
+ */
+export declare function containsLocationLatLng(latitude: number, longitude: number, polygon: LatLngLiteral[], geodesic: boolean): boolean;
+/**
+ * Computes whether the given point lies on or near the edge of a polygon, within a specified
+ * tolerance in meters. The polygon edge is composed of great circle segments if geodesic
+ * is true, and of Rhumb segments otherwise. The polygon edge is implicitly closed -- the
+ * closing segment between the first point and the last point is included.
+ */
+export declare function isLocationOnEdge(point: LatLngLiteral, polygon: LatLngLiteral[], geodesic?: boolean, tolerance?: number): boolean;
+/**
+ * Computes whether the given point lies on or near a polyline, within a specified
+ * tolerance in meters. The polyline is composed of great circle segments if geodesic
+ * is true, and of Rhumb segments otherwise. The polyline is not closed -- the closing
+ * segment between the first point and the last point is not included.
+ */
+export declare function isLocationOnPath(point: LatLngLiteral, polyline: LatLngLiteral[], geodesic?: boolean, tolerance?: number): boolean;
+/**
+ * Computes whether (and where) a given point lies on or near a polyline, within a specified tolerance.
+ * The polyline is not closed -- the closing segment between the first point and the last point is not included.
+ *
+ * @param point our needle
+ * @param poly our haystack
+ * @param geodesic the polyline is composed of great circle segments if geodesic
+ * is true, and of Rhumb segments otherwise
+ * @param tolerance tolerance (in meters)
+ * @return -1 if point does not lie on or near the polyline.
+ * 0 if point is between poly[0] and poly[1] (inclusive),
+ * 1 if between poly[1] and poly[2],
+ * ...,
+ * poly.length-2 if between poly[poly.length - 2] and poly[poly.length - 1]
+ */
+export declare function locationIndexOnPath(point: LatLngLiteral, poly: LatLngLiteral[], geodesic: boolean, tolerance?: number): number;
+/**
+ * Computes whether (and where) a given point lies on or near a polyline, within a specified tolerance.
+ * If closed, the closing segment between the last and first points of the polyline is not considered.
+ *
+ * @param point our needle
+ * @param poly our haystack
+ * @param closed whether the polyline should be considered closed by a segment connecting the last point back to the first one
+ * @param geodesic the polyline is composed of great circle segments if geodesic
+ * is true, and of Rhumb segments otherwise
+ * @param toleranceEarth tolerance (in meters)
+ * @return -1 if point does not lie on or near the polyline.
+ * 0 if point is between poly[0] and poly[1] (inclusive),
+ * 1 if between poly[1] and poly[2],
+ * ...,
+ * poly.length-2 if between poly[poly.length - 2] and poly[poly.length - 1]
+ */
+export declare function locationIndexOnEdgeOrPath(point: LatLngLiteral, poly: LatLngLiteral[], closed: boolean, geodesic: boolean, toleranceEarth: number): number;
+/**
+ * Simplifies the given poly (polyline or polygon) using the Douglas-Peucker decimation
+ * algorithm. Increasing the tolerance will result in fewer points in the simplified polyline
+ * or polygon.
+ *
+ * When the providing a polygon as input, the first and last point of the list MUST have the
+ * same latitude and longitude (i.e., the polygon must be closed). If the input polygon is not
+ * closed, the resulting polygon may not be fully simplified.
+ *
+ * The time complexity of Douglas-Peucker is O(n^2), so take care that you do not call this
+ * algorithm too frequently in your code.
+ *
+ * @param poly polyline or polygon to be simplified. Polygon should be closed (i.e.,
+ * first and last points should have the same latitude and longitude).
+ * @param tolerance in meters. Increasing the tolerance will result in fewer points in the
+ * simplified poly.
+ * @return a simplified poly produced by the Douglas-Peucker algorithm
+ */
+export declare function simplify(poly: LatLngLiteral[], tolerance: number): LatLngLiteral[];
+/**
+ * Returns true if the provided list of points is a closed polygon (i.e., the first and last
+ * points are the same), and false if it is not
+ *
+ * @param poly polyline or polygon
+ * @return true if the provided list of points is a closed polygon (i.e., the first and last
+ * points are the same), and false if it is not
+ */
+export declare function isClosedPolygon(poly: LatLngLiteral[]): boolean;
+/**
+ * Computes the distance on the sphere between the point p and the line segment start to end.
+ *
+ * @param p the point to be measured
+ * @param start the beginning of the line segment
+ * @param end the end of the line segment
+ * @return the distance in meters (assuming spherical earth)
+ */
+export declare function distanceToLine(p: LatLngLiteral, start: LatLngLiteral, end: LatLngLiteral): number;
+/**
+ * Decodes an encoded path string into a sequence of LatLngs.
+ */
+export declare function decode(encodedPath: string): LatLngLiteral[];
+/**
+ * Encodes a sequence of LatLngs into an encoded path string.
+ */
+export declare function encode(path: LatLngLiteral[]): string;

package/dist/src/utils/maps-utils/spherical-util.d.ts

@@ -0,0 +1,67 @@
+import type { LatLngLiteral } from '../../map/lat-lng';
+/**
+ * Returns the heading from one LatLng to another LatLng. Headings are
+ * expressed in degrees clockwise from North within the range [-180,180).
+ *
+ * @return The heading in degrees clockwise from north.
+ */
+export declare function computeHeading(from: LatLngLiteral, to: LatLngLiteral): number;
+/**
+ * Returns the LatLng resulting from moving a distance from an origin
+ * in the specified heading (expressed in degrees clockwise from north).
+ *
+ * @param from The LatLng from which to start.
+ * @param distance The distance to travel.
+ * @param heading The heading in degrees clockwise from north.
+ */
+export declare function computeOffset(from: LatLngLiteral, distance: number, heading: number): LatLngLiteral;
+/**
+ * Returns the location of origin when provided with a LatLng destination,
+ * meters travelled and original heading. Headings are expressed in degrees
+ * clockwise from North. This function returns null when no solution is
+ * available.
+ *
+ * @param to The destination LatLng.
+ * @param distance The distance travelled, in meters.
+ * @param heading The heading in degrees clockwise from north.
+ */
+export declare function computeOffsetOrigin(to: LatLngLiteral, distance: number, heading: number): LatLngLiteral | null;
+/**
+ * Returns the LatLng which lies the given fraction of the way between the
+ * origin LatLng and the destination LatLng.
+ *
+ * @param from The LatLng from which to start.
+ * @param to The LatLng toward which to travel.
+ * @param fraction A fraction of the distance to travel.
+ * @return The interpolated LatLng.
+ */
+export declare function interpolate(from: LatLngLiteral, to: LatLngLiteral, fraction: number): LatLngLiteral;
+/**
+ * Returns the angle between two LatLngs, in radians. This is the same as the distance
+ * on the unit sphere.
+ */
+export declare function computeAngleBetween(from: LatLngLiteral, to: LatLngLiteral): number;
+/**
+ * Returns the distance between two LatLngs, in meters.
+ */
+export declare function computeDistanceBetween(from: LatLngLiteral, to: LatLngLiteral): number;
+/**
+ * Returns the length of the given path, in meters, on Earth.
+ */
+export declare function computeLength(path: LatLngLiteral[]): number;
+/**
+ * Returns the area of a closed path on Earth.
+ *
+ * @param path A closed path.
+ * @return The path's area in square meters.
+ */
+export declare function computeArea(path: LatLngLiteral[]): number;
+/**
+ * Returns the signed area of a closed path on Earth. The sign of the area may be used to
+ * determine the orientation of the path.
+ * "inside" is the surface that does not contain the South Pole.
+ *
+ * @param path A closed path.
+ * @return The loop's area in square meters.
+ */
+export declare function computeSignedArea(path: LatLngLiteral[], radius?: number): number;

package/dist/src/utils/spherical-utils.d.ts

@@ -12,9 +12,16 @@ declare function getDistance(p1: LatLngLiteral, p2: LatLngLiteral): number;
  * @param dist 距离
  */
 export declare function getDestination(pt: LatLngLiteral, angle: number, dist: number): LatLngLiteral;
-/** 球面工具 */
+/**
+ * 球面工具
+ *
+ * 代码copy自[CityBus-vue-admin](https://github.com/TranscodeGroup/CityBus-vue-admin/blob/8b8db7e23e94423747141084eb78ce3331965a4c/src/utils/index.js#L773), 实现似乎有些问题
+ * @deprecated 使用{@link SphericalUtil}替代
+ */
 export declare const SphericalUtils: {
+    /** @deprecated Use {@link SphericalUtil.computeDistanceBetween} instead */
     getDistance: typeof getDistance;
+    /** @deprecated Use {@link SphericalUtil.computeOffset} instead */
     getDestination: typeof getDestination;
 };
 export {};