gs-bim-air 1.6.1-cae.3 → 1.6.1-cae.5

package/types/longan/src/longan/geometry.d.ts

@@ -0,0 +1,229 @@
+import { CylinderCap, Segment, UvType } from "./segment";
+import { IKey } from "./utility";
+export declare class Geometry implements IKey {
+    protected _key: number;
+    protected _color: GeometryColor;
+    protected _property: GeometryProperty;
+    get typeName(): string;
+    get key(): number;
+    get owner(): Segment;
+    get keyType(): any;
+    get color(): GeometryColor;
+    get property(): GeometryProperty;
+    get area(): any;
+    get volume(): any;
+    get shellSize(): any;
+    constructor(key: number);
+    delete(): void;
+    equals(obj: IKey): boolean;
+    moveTo(segment: Segment): void;
+    static fromKey(key: number): Geometry;
+    distanceTo(geom: Geometry, path1?: Int32Array, path2?: Int32Array): Float32Array;
+}
+export declare class Surface extends Geometry {
+    constructor(key: number);
+    ComputeTessellateData(image: Image, precision?: number): {
+        positions: Float32Array;
+        indexes: Int32Array;
+        normals: Float32Array;
+        texcoords: Float32Array;
+    };
+    set normals(value: Float32Array);
+    get normals(): Float32Array;
+    set texCoords(value: Float32Array);
+}
+export declare class Curve extends Geometry {
+    constructor(key: number);
+    ComputeTessellateData(precision?: number): {
+        positions: Float32Array;
+        indexes: Int32Array;
+        normals: Float32Array;
+        texcoords: Float32Array;
+    };
+}
+export declare class Marker extends Geometry {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class PointCloud extends Geometry {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class Line extends Curve {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class Polyline extends Curve {
+    get typeName(): string;
+    get points(): Float32Array;
+    constructor(key: number);
+}
+export declare class Circle extends Curve {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class Cylinder extends Surface {
+    get typeName(): string;
+    get start(): any;
+    get end(): any;
+    get radius(): any;
+    get cap(): string;
+    get points(): Float32Array;
+    get indexes(): Int32Array;
+    constructor(key: number);
+}
+export declare class Shell extends Surface {
+    get typeName(): string;
+    get points(): Float32Array;
+    get indexes(): Int32Array;
+    constructor(key: number);
+    merge(from: Segment): void;
+    static createStripe(points: ArrayLike<number>, normal: ArrayLike<number>, width: number, createUv?: boolean, uvType?: UvType, scale?: ArrayLike<number>): {
+        points: Float32Array;
+        indexes: Int32Array;
+        texcoords: any;
+    };
+    static createVerticalStripe(points: ArrayLike<number>, height: number, createUv?: boolean, uvType?: UvType, scale?: Float64Array): {
+        points: Float32Array;
+        indexes: Int32Array;
+        texcoords: Float32Array;
+    };
+    edit(points: ArrayLike<number>, indexes: ArrayLike<number>): void;
+    editStripe(points: ArrayLike<number>, normal: ArrayLike<number>, width: number, createUv?: boolean, uvType?: UvType, scale?: ArrayLike<number>): void;
+    editVerticalStripe(points: ArrayLike<number>, height: number, createUv?: boolean, uvType?: UvType, scale?: Float64Array): void;
+}
+export declare class Mesh extends Surface {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class Light extends Geometry {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class TriangularShell extends Surface {
+    get typeName(): string;
+    get data(): any;
+    constructor(key: number);
+    merge(from: Segment): void;
+}
+export declare class CircularArc extends Curve {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class Ellipse extends Surface {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class EllipseArc extends Curve {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class PolyCylinder extends Surface {
+    get typeName(): string;
+    constructor(key: number);
+    edit(points: ArrayLike<number>, radii: ArrayLike<number>, cap: CylinderCap): void;
+}
+export declare class ParametricGeometry extends Surface {
+    get typeName(): string;
+    constructor(key: number);
+    get type(): string;
+    get params(): Float64Array;
+    set params(params: Float64Array);
+}
+export declare class ParametricGeometries extends Surface {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare enum TilingType {
+    Clamp = 0,
+    Repeat = 1,
+    Mirror = 2
+}
+export declare enum FilteringType {
+    Linear = 0,
+    Nearest = 1
+}
+export declare class Image extends Geometry {
+    get typeName(): string;
+    get options(): string;
+    get size(): any;
+    get format(): any;
+    get data(): Uint8Array;
+    get name(): string | null;
+    set name(value: string | null);
+    get id(): string | null;
+    set id(value: string | null);
+    get tiling(): TilingType | null;
+    set tiling(value: TilingType | null);
+    get filtering(): FilteringType | null;
+    set filtering(value: FilteringType | null);
+    get mipMap(): boolean | null;
+    set mipMap(value: boolean | null);
+    get discard(): boolean | null;
+    set discard(value: boolean | null);
+    get local(): boolean | null;
+    set local(value: boolean | null);
+    get externalLoad(): boolean | null;
+    set externalLoad(value: boolean | null);
+    get scale(): [number, number] | null;
+    set scale(value: [number, number] | null);
+    set translate(value: [number, number] | null);
+    get translate(): [number, number] | null;
+    set rotate(value: number | null);
+    get rotate(): number | null;
+    constructor(key: number);
+}
+export declare class VectorText extends Surface {
+    get typeName(): string;
+    constructor(key: number);
+}
+export declare class CuttingPlanes extends Geometry {
+    get typeName(): string;
+    get planes(): any;
+    constructor(key: number);
+    edit(planes: ArrayLike<number>): void;
+}
+declare class Attribute {
+    protected _key: number;
+    constructor(key: number);
+}
+export declare class GeometryColor extends Attribute {
+    constructor(key: number);
+    get face(): ArrayLike<number> | null;
+    set face(val: ArrayLike<number> | null);
+    setFace(color: ArrayLike<number>): this;
+    unsetFace(): this;
+    get line(): ArrayLike<number> | null;
+    set line(val: ArrayLike<number> | null);
+    setLine(color: ArrayLike<number>): this;
+    unsetLine(): this;
+    get marker(): ArrayLike<number> | null;
+    set marker(val: ArrayLike<number> | null);
+    setMarker(color: ArrayLike<number>): this;
+    unsetMarker(): this;
+    get edge(): ArrayLike<number> | null;
+    set edge(val: ArrayLike<number> | null);
+    setEdge(color: ArrayLike<number>): this;
+    unsetEdge(): this;
+    get vertex(): ArrayLike<number> | null;
+    set vertex(val: ArrayLike<number> | null);
+    setVertex(color: ArrayLike<number>): this;
+    unsetVertex(): this;
+}
+export declare class GeometryProperty extends Attribute {
+    constructor(key: number);
+    get list(): any;
+    addBoolean(name: string, value: boolean): void;
+    addInteger(name: string, value: number): void;
+    addDouble(name: string, value: number): void;
+    addString(name: string, value: string): void;
+    addJson(name: string, value: string): void;
+    showBoolean(name: string): boolean;
+    showInteger(name: string): number;
+    showDouble(name: string): number;
+    showString(name: string): string;
+    remove(name: string): void;
+    clear(): void;
+    exists(name: string): boolean;
+}
+export {};

package/types/longan/src/longan/gs.collections.d.ts

@@ -0,0 +1,76 @@
+export declare class StringKeyList<T> {
+    items: {
+        [key: string]: T;
+    };
+    private len;
+    constructor();
+    add(key: string, value: T): void;
+    remove(key: string): boolean;
+    clear(): void;
+    has(key: string): boolean;
+    get(key: string): T;
+    count(): number;
+    forEach(callback: (key: string, value: T) => any): void;
+}
+export declare class NumberKeyList<T> {
+    typeName: string;
+    items: {
+        [key: number]: T;
+    };
+    private len;
+    constructor();
+    add(key: number, value: T): void;
+    remove(key: number): boolean;
+    clear(): void;
+    has(key: number): boolean;
+    get(key: number): T;
+    first(): T;
+    count(): number;
+    forEach(callback: (key: number, value: T) => any): void;
+}
+export declare class NumberSortedList<T> {
+    typeName: string;
+    items: Array<[number, T]>;
+    constructor();
+    get count(): number;
+    indexOf(value: T): number;
+    indexOfKey(key: number): number;
+    add(key: number, value: T): void;
+    keyByIndex(index: number): number;
+    valueByIndex(index: number): T;
+    forEach(callback: (value: T) => any): void;
+}
+export declare class List<T> {
+    typeName: string;
+    items: Array<T>;
+    constructor(len?: number);
+    count(): number;
+    indexOf(value: T): number;
+    lastIndexOf(value: T): number;
+    add(...value: T[]): void;
+    insert(index: number, value: T): void;
+    addRange(list: List<T>): void;
+    remove(value: T): boolean;
+    removeAt(index: number): boolean;
+    removeRange(index: number, count: number): boolean;
+    clear(): void;
+    get(index: number): T;
+    contains(item: T): boolean;
+    forEach(callback: (value: T, index?: number) => any): void;
+    reverseForEach(callback: (value: T, index?: number) => any): void;
+}
+export declare class Stack<T> {
+    typeName: string;
+    items: Array<T>;
+    index: number;
+    constructor(len?: number);
+    count(): number;
+    push(elem: T): void;
+    add(elem: T): void;
+    pop(): T | null;
+    peek(): T | null;
+    peekDirect(): T;
+    peekPrev(): T | null;
+    get(index: number): T;
+    forEach(callback: (value: T) => any): void;
+}

package/types/longan/src/longan/gs.math.d.ts

@@ -0,0 +1,309 @@
+import { List } from "./gs.collections";
+export declare class Point {
+    static add(p1: Float32Array, p2: Float32Array): Float32Array;
+    static subtract(p1: Float32Array, p2: Float32Array): Float32Array;
+    static clone(p: Float32Array): Float32Array;
+}
+export declare class DPoint {
+    static add(p1: Float64Array, p2: Float64Array): Float64Array;
+    static subtract(p1: Float64Array, p2: Float64Array): Float64Array;
+    static clone(p: Float64Array): Float64Array;
+}
+export declare class Vector {
+    static isZero(v: Float32Array): boolean;
+    static multiply(v: Float32Array, num: number): Float32Array;
+    static divide(v: Float32Array, num: number): Float32Array;
+    static normalize(v: Float32Array): void;
+    static normalizeVector(v: Float32Array): Float32Array;
+    static multi(v1: Float32Array, v2: Float32Array): number;
+    static cross(v1: Float32Array, v2: Float32Array): Float32Array;
+    static module(v: Float32Array): number;
+    static reverse(v: Float32Array): void;
+    static clone(v: Float32Array): Float32Array;
+    static includeAngle(v0: Float32Array, v1: Float32Array): number;
+    static angle(v0: Float32Array, v1: Float32Array, normal?: Float32Array): number;
+}
+export declare class DVector {
+    static isZero(v: Float64Array): boolean;
+    static multiply(v: Float64Array, num: number): Float64Array;
+    static divide(v: Float64Array, num: number): Float64Array;
+    static normalize(v: Float64Array): void;
+    static normalizeVector(v: Float64Array): Float64Array;
+    static multi(v1: Float64Array, v2: Float64Array): number;
+    static cross(v1: Float64Array, v2: Float64Array): Float64Array;
+    static module(v: Float64Array): number;
+    static reverse(v: Float64Array): void;
+    static clone(v: Float64Array): Float64Array;
+    static includeAngle(v0: Float64Array, v1: Float64Array): number;
+    static angle(v0: Float64Array, v1: Float64Array, normal?: Float64Array): number;
+}
+export declare class Matrix4 {
+    static clone(m: Float32Array): Float32Array;
+    static identity(): Float32Array;
+    static isIdentity(m: Float32Array): boolean;
+    /**
+     * 矩阵相乘
+     * @param m1
+     * @param m2
+     * @returns
+     */
+    static multiply(m1: Float32Array, m2: Float32Array): Float32Array;
+    /**
+     * 点矩阵变换
+     * @param m 矩阵
+     * @param p 点
+     * @returns 变换后的点
+     */
+    static multiplyPoint(m: Float32Array, p: Float32Array): Float32Array;
+    /**
+     * 点数组矩阵变换
+     * @param m 矩阵
+     * @param p 点数组
+     * @returns 变换后的点数组
+     */
+    static multiplyPoints(m: Float32Array, ps: Float32Array): Float32Array;
+    static multiplyVector(m: Float32Array, v: Float32Array): Float32Array;
+    static multiplyBoundingBox(m: Float32Array, bb: Float32Array): Float32Array;
+    static Inverse(m: Float32Array): void;
+    static InverseMatrix(m: Float32Array): Float32Array;
+    static Transpose(m: Float32Array): void;
+    static TransposeMatrix(m: Float32Array): Float32Array;
+    static translateMatrix(x: number, y: number, z: number): Float32Array;
+    static translate(m: Float32Array, x: number, y: number, z: number): void;
+    static scaleMatrix(x: number, y: number, z: number): Float32Array;
+    static scale(m: Float32Array, x: number, y: number, z: number): void;
+    static rotate(axis: Float32Array, alpha: number): Float32Array;
+    /**
+     * 指定点轴旋转
+     * @param origin 点
+     * @param axis 旋转轴
+     * @param alpha 弧度
+     * @returns 变换矩阵
+     */
+    static rotateByAxis(origin: Float32Array, axis: Float32Array, alpha: number): Float32Array;
+    static ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Float32Array;
+    static lookat(eyeX: number, eyeY: number, eyeZ: number, centerX: number, centerY: number, centerZ: number, upX: number, upY: number, upZ: number): Float32Array;
+    static getTranslate(m: Float32Array): Float32Array;
+    static getScale(m: Float32Array): Float32Array;
+    static getRotate(m: Float32Array): Float32Array;
+}
+export declare class DMatrix4 {
+    static clone(m: Float64Array): Float64Array;
+    static identity(): Float64Array;
+    static multiply(m1: Float64Array, m2: Float64Array): Float64Array;
+    static multiplyPoint(m: Float64Array, p: Float64Array): Float64Array;
+    static multiplyVector(m: Float64Array, v: Float64Array): Float64Array;
+    static multiplyBoundingBox(m: Float64Array, bb: Float64Array): Float64Array;
+    static Inverse(m: Float64Array): void;
+    static InverseMatrix(m: Float64Array): Float64Array;
+    static Transpose(m: Float64Array): void;
+    static TransposeMatrix(m: Float64Array): Float64Array;
+    static translateMatrix(x: number, y: number, z: number): Float64Array;
+    static translate(m: Float64Array, x: number, y: number, z: number): void;
+    static scaleMatrix(x: number, y: number, z: number): Float64Array;
+    static scale(m: Float64Array, x: number, y: number, z: number): void;
+    static rotate(axis: Float64Array, alpha: number): Float64Array;
+    static rotateByAxis(origin: Float64Array, axis: Float64Array, alpha: number): Float64Array;
+    static ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Float64Array;
+    static lookat(eyeX: number, eyeY: number, eyeZ: number, centerX: number, centerY: number, centerZ: number, upX: number, upY: number, upZ: number): Float64Array;
+    static getTranslate(m: Float64Array): Float64Array;
+    static getScale(m: Float64Array): Float64Array;
+    static getRotate(m: Float64Array): Float64Array;
+}
+export declare class Wcs {
+    origin: Float32Array;
+    x_axis: Float32Array;
+    y_axis: Float32Array;
+    z_axis: Float32Array;
+    local: Float32Array;
+    model: Float32Array;
+    constructor(origin: Float32Array, x_axis: Float32Array, y_axis: Float32Array);
+    toLocalPoint(point: Float32Array): Float32Array;
+    toLocalVector(vector: Float32Array): Float32Array;
+    toModelPoint(point: Float32Array): Float32Array;
+    toModelVector(vector: Float32Array): Float32Array;
+}
+export declare class DWcs {
+    origin: Float64Array;
+    x_axis: Float64Array;
+    y_axis: Float64Array;
+    z_axis: Float64Array;
+    local: Float64Array;
+    model: Float64Array;
+    constructor(origin: Float64Array, x_axis: Float64Array, y_axis: Float64Array);
+    /**
+     * 获取局部坐标位置
+     * @param point
+     * @returns
+     */
+    toLocalPoint(point: Float64Array): Float64Array;
+    /**
+     * 获取局部坐标位置列表
+     * @param points
+     * @returns
+     */
+    toLocalPoints(points: Float64Array): Float64Array;
+    /**
+     * 获取局部坐标法向
+     * @param vector
+     * @returns
+     */
+    toLocalVector(vector: Float64Array): Float64Array;
+    /**
+     * 获取世界坐标位置
+     * @param point
+     * @returns
+     */
+    toModelPoint(point: Float64Array): Float64Array;
+    /**
+     * 获取世界坐标位置列表
+     * @param points
+     * @returns
+     */
+    toModelPoints(points: Float64Array): Float64Array;
+    /**
+     * 获取世界坐标法向
+     * @param vector
+     * @returns
+     */
+    toModelVector(vector: Float64Array): Float64Array;
+}
+export declare class Tolerance {
+    static resabs: number;
+    static resnor: number;
+    static sameValue(a: number, b: number): boolean;
+    static sameValueFloatArray(a: Float32Array, b: Float32Array): boolean;
+    static isValueInInterval(v: number, a: number, b: number): boolean;
+}
+export declare class DTolerance {
+    static resabs: number;
+    static resnor: number;
+    static sameValue(a: number, b: number): boolean;
+    static sameValueFloatArray(a: Float64Array, b: Float64Array): boolean;
+}
+export declare class BoundingBox {
+    static setNull(bb: Float32Array): void;
+    static isNull(bb: Float32Array): boolean;
+    static extend(bb: Float32Array, b: Float32Array): void;
+    static extendByPoint(bb: Float32Array, pt: Float32Array): void;
+    static center(bb: Float32Array): Float32Array;
+    static radius(bb: Float32Array): number;
+    static isIntersecting(bb1: Float32Array, bb2: Float32Array): boolean;
+    static isPointIn(p: Float32Array, bb: Float32Array): boolean;
+}
+export declare class DBoundingBox {
+    static setNull(bb: Float64Array): void;
+    static isNull(bb: Float64Array): boolean;
+    static extend(bb: Float64Array, b: Float64Array): void;
+    static extendByPoint(bb: Float64Array, pt: Float64Array): void;
+    static center(bb: Float64Array): Float64Array;
+    static radius(bb: Float64Array): number;
+    static isPointIn(p: Float64Array, bb: Float64Array): boolean;
+}
+export declare class GeometryOperators {
+    static closestPoint(p0: Float32Array, v0: Float32Array, p1: Float32Array, v1: Float32Array): any;
+    static intersectionLineLine(line0_p0: Float32Array, line0_p1: Float32Array, line1_p0: Float32Array, line1_p1: Float32Array): any;
+    static intersectionLineLine1(line0_point: Float32Array, line0_direct: Float32Array, line1_point: Float32Array, line1_direct: Float32Array): any;
+    static intersectionLineSegmentLineSegment(line0_p0: Float32Array, line0_p1: Float32Array, line1_p0: Float32Array, line1_p1: Float32Array): any;
+    static intersectionLineSegmentPlane(line_start: Float32Array, line_end: Float32Array, plane_root: Float32Array, plane_normal: Float32Array): {
+        res: boolean;
+        param?: undefined;
+        pos?: undefined;
+    } | {
+        res: boolean;
+        param: any;
+        pos: any;
+    };
+    static samePoint(p0: Float32Array, p1: Float32Array): boolean;
+    static sameVector(v0: Float32Array, v1: Float32Array): boolean;
+    static distance(p1: Float32Array, p2: Float32Array): number;
+    static distancePoint(or: Float32Array, dir: Float32Array, va: number): Float32Array;
+    static projectPointToLine(point: Float32Array, origin: Float32Array, direction: Float32Array): Float32Array;
+    static projectPointToLineWithParam(point: Float32Array, origin: Float32Array, direction: Float32Array): {
+        point: Float32Array;
+        param: number;
+    };
+    static projectPointToLine1(point: Float32Array, lineStart: Float32Array, lineEnd: Float32Array): Float32Array;
+    static projectPointToPlane(point: Float32Array, root: Float32Array, normal: Float32Array): Float32Array;
+    static isParallel(v1: Float32Array, v2: Float32Array): boolean;
+    static isPerpendicular(v1: Float32Array, v2: Float32Array): boolean;
+    static intersectionLinePlane(line_point: Float32Array, line_dir: Float32Array, plane_point: Float32Array, plane_dir: Float32Array): {
+        res: boolean;
+        param?: undefined;
+        pos?: undefined;
+    } | {
+        res: boolean;
+        param: number;
+        pos: Float32Array;
+    };
+    static polygonNormal(polygon: Float32Array): Float32Array;
+    static inversePolygon(polygon: Float32Array): void;
+    static isPointInLineSegment(point: Float32Array, line_start: Float32Array, line_end: Float32Array): boolean;
+    static isPointOnPolygonXy(point: Float32Array, polygon_points: Float32Array, polygon_indexes: Int32Array): boolean;
+    static isPointInPolygonXy(point: Float32Array, polygon: Float32Array): boolean;
+    static createRingPoints(origin: Float32Array, x_axis: Float32Array, y_axis: Float32Array, paramList: Float32Array, length: number): Float32Array;
+    static lineParam(point: Float32Array, origin: Float32Array, direction: Float32Array): number;
+    static lineParam1(point: Float32Array, lineStart: Float32Array, lineEnd: Float32Array): number;
+    static angleBetween(v0: Float32Array, v1: Float32Array): number;
+    static angleBetweenByNormal(v0: Float32Array, v1: Float32Array, normal: Float32Array): number;
+    static IsParallel(firstDirection: Float32Array, secondDirection: Float32Array): boolean;
+    static includeAngleBetween(v0: Float32Array, v1: Float32Array): number;
+    static reversePoints(points: ArrayLike<number>): number[];
+}
+export declare class DGeometryOperators {
+    static closestPoint(p0: Float64Array, v0: Float64Array, p1: Float64Array, v1: Float64Array): any;
+    static samePoint(p0: Float64Array, p1: Float64Array): boolean;
+    static samePointWithTolerance(p0: Float64Array, p1: Float64Array, tolerance: number): boolean;
+    static sameVector(v0: Float64Array, v1: Float64Array): boolean;
+    static distance(p1: Float64Array, p2: Float64Array): number;
+    static distancePoint(or: Float64Array, dir: Float64Array, va: number): Float64Array;
+    static projectPointToLine(point: Float64Array, origin: Float64Array, direction: Float64Array): Float64Array;
+    static projectPointToLine1(point: Float64Array, lineStart: Float64Array, lineEnd: Float64Array): Float64Array;
+    static projectPointToLineWithParam(point: Float64Array, origin: Float64Array, direction: Float64Array): {
+        point: Float64Array;
+        param: number;
+    };
+    static projectPointToPlane(point: Float64Array, root: Float64Array, normal: Float64Array): Float64Array;
+    static angleBetween(v0: Float64Array, v1: Float64Array): number;
+    static angleBetweenByNormal(v0: Float64Array, v1: Float64Array, normal: Float64Array): number;
+    static isParallel(v1: Float64Array, v2: Float64Array): boolean;
+    static isPerpendicular(v1: Float64Array, v2: Float64Array): boolean;
+    static intersectionLineLine(line0_p0: Float64Array, line0_p1: Float64Array, line1_p0: Float64Array, line1_p1: Float64Array): any;
+    static intersectionLineSegmentLineSegment(line0_p0: Float64Array, line0_p1: Float64Array, line1_p0: Float64Array, line1_p1: Float64Array): any;
+    static intersectionLinePlane(line_point: Float64Array, line_dir: Float64Array, plane_point: Float64Array, plane_dir: Float64Array): {
+        res: boolean;
+        param?: undefined;
+        pos?: undefined;
+    } | {
+        res: boolean;
+        param: number;
+        pos: Float64Array;
+    };
+    static intersectionLineSegmentPlane(line_start: Float64Array, line_end: Float64Array, plane_root: Float64Array, plane_normal: Float64Array): {
+        res: boolean;
+        param?: undefined;
+        pos?: undefined;
+    } | {
+        res: boolean;
+        param: any;
+        pos: any;
+    };
+    static polygonNormal(polygon: Float64Array): Float64Array;
+    static inversePolygon(polygon: Float64Array): void;
+    static isPointInLineSegment(point: Float64Array, line_start: Float64Array, line_end: Float64Array): boolean;
+    static isPointOnPolygonXy(point: Float64Array, polygon_points: Float64Array, polygon_indexes: Float64Array): boolean;
+    static isPointInPolygonXy(point: Float64Array, polygon: Float64Array): boolean;
+    static createRingPoints(origin: Float64Array, x_axis: Float64Array, y_axis: Float64Array, paramList: Float64Array, length: number): Float64Array;
+    static lineParam(point: Float64Array, origin: Float64Array, direction: Float64Array): number;
+    static lineParam1(point: Float64Array, lineStart: Float64Array, lineEnd: Float64Array): number;
+    /**
+     * 重构多边形
+     * @param polygon
+     * @param tolerance 容差
+     * @returns
+     */
+    static arrangePolygon(polygon: Float64Array, tolerance: number): Float64Array;
+    static createPolylinesBySegments(points: ArrayLike<number>): List<Float64Array>;
+    static includeAngleBetween(v0: Float64Array, v1: Float64Array): number;
+    static reversePoints(points: ArrayLike<number>): number[];
+}