ol-plot-tool/dist/index.d.ts

ol plot tool

import { Feature } from 'ol';
import { Fill } from 'ol/style';
import * as Geometry from './geometry';
import { Icon } from 'ol/style';
import { LineString } from 'ol/geom';
import { Observable } from 'ol';
import Overlay from 'ol/Overlay';
import { Point as Point_2 } from 'ol/geom';
import { Polygon } from 'ol/geom';
import { RegularShape } from 'ol/style';
import { Stroke } from 'ol/style';
import { Style } from 'ol/style';
import { Text as Text_2 } from 'ol/style';
import type VectorLayer from 'ol/layer/Vector';

declare class Arc extends LineString {
    type: PlotTypes;
    fixPointCount: number;
    freehand: boolean;
    map: any;
    points: Point_3[];
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): void;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {ol.Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): PlotUtils.Point[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class AssaultDirection extends FineArrow {
    constructor(coordinates: any, points: any, params: any);
}

declare class AttackArrow extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    headWidthFactor: number;
    headHeightFactor: number;
    neckWidthFactor: number;
    neckHeightFactor: number;
    tailWidthFactor: number;
    headTailFactor: number;
    swallowTailFactor: number;
    swallowTailPnt: WithNull<Point_3>;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 插值箭形上的点
     * @param pnt1
     * @param pnt2
     * @param pnt3
     * @param clockWise
     * @returns {Array.<T>}
     */
    getArrowPoints(pnt1: any, pnt2: any, pnt3: any, clockWise: any): PlotUtils.Point[] | undefined;
    /**
     * 插值头部点
     * @param points
     * @param tailLeft
     * @param tailRight
     * @returns {[*,*,*,*,*]}
     */
    getArrowHeadPoints(points: any, tailLeft?: Point_3, tailRight?: Point_3): any[] | undefined;
    /**
     * 插值面部分数据
     * @param points
     * @param neckLeft
     * @param neckRight
     * @param tailWidthFactor
     * @returns {Array.<*>}
     */
    getArrowBodyPoints(points: any, neckLeft: any, neckRight: any, tailWidthFactor: any): Array<Point_3>;
    /**
     * 获取对称点
     * @param linePnt1
     * @param linePnt2
     * @param point
     * @returns {*}
     */
    getTempPoint4(linePnt1: any, linePnt2: any, point: any): any;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {ol.Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): PlotUtils.Point[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare function bindAll(fns: any, context: any): void;

declare class Circle extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    generate(): false | undefined;
    /**
     * 对圆边线进行插值
     * @param center
     * @param radius
     * @returns {null}
     */
    generatePoints(center: any, radius: any): Point_3[];
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {{}|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class ClosedCurve extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    t: number;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): PlotUtils.Point[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class Curve extends LineString {
    type: PlotTypes;
    fixPointCount: number;
    map: any;
    points: Point_3[];
    freehand: boolean;
    t: number;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {ol.Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class CurveFlag extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 插值点数据
     * @param points
     * @returns {Array}
     */
    calculatePonits(points: any): Point_3[];
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class DoubleArrow extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    neckHeightFactor: number;
    headHeightFactor: number;
    headWidthFactor: number;
    neckWidthFactor: number;
    connPoint: WithNull<Point_3>;
    tempPoint4: WithNull<Point_3>;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 插值箭形上的点
     * @param pnt1
     * @param pnt2
     * @param pnt3
     * @param clockWise
     * @returns {Array.<T>}
     */
    getArrowPoints(pnt1: any, pnt2: any, pnt3: any, clockWise: any): PlotUtils.Point[] | undefined;
    /**
     * 插值头部点
     * @param points
     * @returns {[*,*,*,*,*]}
     */
    getArrowHeadPoints(points: any): any[] | undefined;
    /**
     * 插值面部分数据
     * @param points
     * @param neckLeft
     * @param neckRight
     * @param tailWidthFactor
     * @returns {Array.<*>}
     */
    getArrowBodyPoints(points: any, neckLeft: any, neckRight: any, tailWidthFactor: any): PlotUtils.Point[];
    /**
     * 获取对称点
     * @param linePnt1
     * @param linePnt2
     * @param point
     * @returns {*}
     */
    getTempPoint4(linePnt1: any, linePnt2: any, point: any): any;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): PlotUtils.Point[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class Ellipse extends Polygon {
    type: PlotTypes;
    fixPointCount: number;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    generate(): false | undefined;
    /**
     * 对圆边线进行插值
     * @param center
     * @param majorRadius
     * @param minorRadius
     * @returns {*}
     */
    generatePoints(center: any, majorRadius: any, minorRadius: any): Point_3[];
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {{}|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class FineArrow extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    neckAngle: number;
    headAngle: number;
    headWidthFactor: number;
    neckWidthFactor: number;
    tailWidthFactor: number;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): PlotUtils.Point[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class FreeHandLine extends LineString {
    type: PlotTypes;
    fixPointCount: number;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): void;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {ol.Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class FreePolygon extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): void;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class GatheringPlace extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    t: number;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): PlotUtils.Point[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

/**
 * 通过三个点获取方位角
 * @param pntA
 * @param pntB
 * @param pntC
 * @returns {number}
 */
declare const getAngleOfThreePoints: (pntA: Point_3, pntB: Point_3, pntC: Point_3) => number;

/**
 * 插值弓形线段点
 * @param center
 * @param radius
 * @param startAngle
 * @param endAngle
 * @returns {null}
 */
declare const getArcPoints: (center: Point_3, radius: number, startAngle: number, endAngle: number) => Point_3[];

/**
 * 获取方位角（地平经度）
 * @param startPoint
 * @param endPoint
 * @returns {*}
 */
declare const getAzimuth: (startPoint: Point_3, endPoint: Point_3) => number;

/**
 * 获取基础长度
 * @param points
 * @returns {number}
 */
declare const getBaseLength: (points: Point_3[]) => number;

/**
 * 贝塞尔曲线
 * @param points
 * @returns {*}
 */
declare const getBezierPoints: (points: Point_3[]) => Point_3[];

/**
 * 获取二项分布
 * @param n
 * @param index
 * @returns {number}
 */
declare const getBinomialFactor: (n: number, index: number) => number;

/**
 * getBisectorNormals
 * @param t
 * @param pnt1
 * @param pnt2
 * @param pnt3
 * @returns {[*,*]}
 */
declare const getBisectorNormals: (t: number, pnt1: Point_3, pnt2: Point_3, pnt3: Point_3) => Point_3[];

/**
 * 通过三个点确定一个圆的中心点
 * @param point1
 * @param point2
 * @param point3
 */
declare const getCircleCenterOfThreePoints: (point1: Point_3, point2: Point_3, point3: Point_3) => Point_3;

/**
 * 获取立方值
 * @param t
 * @param startPnt
 * @param cPnt1
 * @param cPnt2
 * @param endPnt
 * @returns {[*,*]}
 */
declare const getCubicValue: (t: number, startPnt: Point_3, cPnt1: Point_3, cPnt2: Point_3, endPnt: Point_3) => Point_3;

/**
 * 插值曲线点
 * @param t
 * @param controlPoints
 * @returns {null}
 */
declare const getCurvePoints: (t: number, controlPoints: Point_3[]) => Point_3[];

/**
 * 获取阶乘数据
 * @param n
 * @returns {number}
 */
declare const getFactorial: (n: number) => number;

/**
 * 获取交集的点
 * @param pntA
 * @param pntB
 * @param pntC
 * @param pntD
 * @returns {[*,*]}
 */
declare const getIntersectPoint: (pntA: Point_3, pntB: Point_3, pntC: Point_3, pntD: Point_3) => Point_3;

/**
 * 获取左边控制点
 * @param controlPoints
 * @param t
 * @returns {[*,*]}
 */
declare const getLeftMostControlPoint: (controlPoints: Point_3[], t: number) => Point_3;

/**
 * 获取默认三点的内切圆
 * @param pnt1
 * @param pnt2
 * @param pnt3
 * @returns {[*,*]}
 */
declare const getNormal: (pnt1: Point_3, pnt2: Point_3, pnt3: Point_3) => Point_3;

/**
 * 获取线上的点
 * @param t
 * @param startPnt
 * @param endPnt
 * @returns {[*,*]}
 */
declare const getPointOnLine: (t: number, startPnt: Point_3, endPnt: Point_3) => Point_3;

/**
 * 插值线性点
 * @param points
 * @returns {*}
 */
declare const getQBSplinePoints: (points: Point_3[]) => Point_3[];

/**
 * 得到二次线性因子
 * @param k
 * @param t
 * @returns {number}
 */
declare const getQuadricBSplineFactor: (k: number, t: number) => number;

/**
 * 获取右边控制点
 * @param controlPoints
 * @param t
 * @returns {[*,*]}
 */
declare const getRightMostControlPoint: (controlPoints: Point_3[], t: number) => Point_3;

/**
 * 根据起止点和旋转方向求取第三个点
 * @param startPnt
 * @param endPnt
 * @param angle
 * @param distance
 * @param clockWise
 * @returns {[*,*]}
 */
declare const getThirdPoint: (startPnt: Point_3, endPnt: Point_3, angle: number, distance: number, clockWise?: boolean) => Point_3;

/**
 * 生成随机字符串
 * @returns {*}
 */
declare function getuuid(noBit?: boolean): any;

/**
 * 判断是否是顺时针
 * @param pnt1
 * @param pnt2
 * @param pnt3
 * @returns {boolean}
 */
declare const isClockWise: (pnt1: Point_3, pnt2: Point_3, pnt3: Point_3) => boolean;

/**
 * 判断是否为对象
 * @param value
 * @returns {boolean}
 */
declare const isObject: (value: any) => value is object;

declare class Lune extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): PlotUtils.Point[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

/**
 * 计算两个坐标之间的距离
 * @param pnt1
 * @param pnt2
 * @returns {number}
 * @constructor
 */
declare const MathDistance: (pnt1: Point_3, pnt2: Point_3) => number;

/**
 * merge
 * @param a
 * @param b
 * @returns {*}
 */
declare const merge: (a: any, b: any) => any;

/**
 * 求取两个坐标的中间坐标
 * @param point1
 * @param point2
 * @returns {[*,*]}
 * @constructor
 */
declare const Mid: (point1: Point_3, point2: Point_3) => Point_3;

declare class olPlot extends Observable {
    static PlotTypes: typeof PlotTypes;
    static Geometry: typeof Geometry;
    static StyleFactory: typeof StyleFactory;
    plotDraw: PlotDraw;
    plotEdit: PlotEdit;
    plotUtils: PlotUtils_2;
    constructor(map: any, options: any);
}
export default olPlot;

declare class Pennant extends Point_2 {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    options: any;
    constructor(coordinates: any, point: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    generate(): void;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {{}|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class PlotDraw extends Observable {
    map: any;
    ctx: olPlot;
    options: any;
    feature: WithNull<Feature>;
    featureId: string;
    points: any[];
    plotType: WithNull<PlotTypes>;
    plotParams: any;
    mapViewport: HTMLElement;
    layerName: string;
    drawLayer: VectorLayer<any>;
    plot: WithNull<PlotTypesSource>;
    private drawInteraction_;
    private dblClickZoomInteraction;
    constructor(map: any, params: any, ctx: any);
    /**
     * 创建Plot
     * @param type
     * @param points
     * @param _params
     * @returns {*}
     */
    private createPlot;
    active(type: PlotTypes, params?: {}): void;
    /**
     * 激活工具
     * @param type
     * @param params
     */
    activate(type: any, params?: {}): void;
    /**
     * 激活交互工具
     */
    activeInteraction(): void;
    textAreaDrawStart(event: any): void;
    /**
     * 绘制结束
     * @param event
     */
    textAreaDrawEnd(event: any): void;
    disActive(): void;
    /**
     * 取消激活状态
     */
    deactivate(): void;
    /**
     * PLOT是否处于激活状态
     * @returns {boolean}
     */
    isDrawing(): boolean;
    /**
     * 地图事件处理
     * 激活工具后第一次点击事件
     * @param event
     */
    private mapFirstClickHandler;
    /**
     * 地图点击事件处理
     * @param event
     * @returns {boolean}
     */
    private mapNextClickHandler;
    /**
     * 地图双击事件处理
     * @param event
     */
    private mapDoubleClickHandler;
    /**
     * 地图事件处理
     * 鼠标移动事件
     * @param event
     * @returns {boolean}
     */
    private mapMouseMoveHandler;
    /**
     * 移除事件监听
     */
    private removeEventHandlers;
    /**
     * 绘制结束
     */
    private drawEnd;
    /**
     * 添加要素
     */
    addFeature(): void;
    /**
     * 取消激活地图交互工具
     */
    private deactiveMapTools;
    /**
     * 激活已取消的地图工具
     * 还原之前状态
     */
    private activateMapTools;
    /**
     * 创建删除按钮
     */
    private createCloseBtnMark;
    /**
     * 创建删除按钮Overlay标记
     */
    private createCloseBtnOverlay;
    /**
     * 根据FeatureId移除标记(目标特征+删除按钮Overlay)
     */
    private removeMarkByFeatureId;
}

declare class PlotEdit extends Observable {
    map: any;
    mapViewport: HTMLElement;
    activePlot: WithNull<any>;
    private startPoint;
    private controlPoints;
    private mouseOver;
    private mapDragPan;
    private activeControlPointId;
    private elementTable;
    private ghostControlPoints;
    private previousCursor_;
    constructor(map: any);
    /**
     * 初始化提示DOM
     * @returns {boolean}
     */
    private initHelperDom;
    /**
     * 获取地图元素的父元素
     * @returns {*}
     */
    private getMapParentElement;
    /**
     * 销毁帮助提示DOM
     */
    private destroyHelperDom;
    /**
     * 初始化要素控制点
     */
    private initControlPoints;
    private handleContextmenu;
    /**
     * 对控制点的移动事件
     * @param e
     */
    private controlPointMouseMoveHandler2;
    /**
     * 对控制点的鼠标按下事件
     * @param e
     */
    private controlPointMouseDownHandler;
    /**
     * 对控制点的移动事件
     * @param event
     */
    private controlPointMouseMoveHandler;
    /**
     * 对控制点的鼠标抬起事件
     */
    private controlPointMouseUpHandler;
    /**
     * 激活工具
     * @param plot
     * @returns {boolean}
     */
    activate(plot: any): void;
    /**
     * 获取要素的控制点
     * @returns {Array}
     */
    private getControlPoints;
    /**
     * 鼠标移出要编辑的要素范围
     * @param e
     * @returns {T|undefined}
     */
    private plotMouseOverOutHandler;
    /**
     * 在要编辑的要素按下鼠标按键
     * @param event
     */
    private plotMouseDownHandler;
    /**
     * 在要编辑的要素上移动鼠标
     * @param event
     */
    private plotMouseMoveHandler;
    /**
     * 鼠标抬起事件
     */
    private plotMouseUpHandler;
    /**
     * 取消事件关联
     */
    private disconnectEventHandlers;
    /**
     * 取消激活工具
     */
    deactivate(): void;
    /**
     * 禁止地图的拖拽平移
     */
    private disableMapDragPan;
    /**
     * 激活地图的拖拽平移
     */
    private enableMapDragPan;
}

declare enum PlotTypes {
    TEXTAREA = "TextArea",
    ARC = "Arc",
    CURVE = "Curve",
    GATHERING_PLACE = "GatheringPlace",
    POLYLINE = "Polyline",
    FREEHANDLINE = "FreeHandLine",
    POINT = "Point",
    PENNANT = "Pennant",
    RECTANGLE = "RectAngle",
    CIRCLE = "Circle",
    ELLIPSE = "Ellipse",
    LUNE = "Lune",
    SECTOR = "Sector",
    CLOSED_CURVE = "ClosedCurve",
    POLYGON = "Polygon",
    FREE_POLYGON = "FreePolygon",
    ATTACK_ARROW = "AttackArrow",
    DOUBLE_ARROW = "DoubleArrow",
    STRAIGHT_ARROW = "StraightArrow",
    FINE_ARROW = "FineArrow",
    ASSAULT_DIRECTION = "AssaultDirection",
    TAILED_SQUAD_COMBAT = "TailedSquadCombat",
    TAILED_ATTACK_ARROW = "TailedAttackArrow",
    SQUAD_COMBAT = "SquadCombat",
    RECTFLAG = "RectFlag",
    TRIANGLEFLAG = "TriangleFlag",
    CURVEFLAG = "CurveFlag",
    RECTINCLINED1 = "RectInclined1",
    RECTINCLINED2 = "RectInclined2"
}

declare type PlotTypesSource = Point | Pennant | Polyline | Arc | Circle | Curve | FreeHandLine | RectAngle | Ellipse | Lune | Sector | ClosedCurve | Polygon_2 | FreePolygon | AttackArrow | DoubleArrow | StraightArrow | FineArrow | AssaultDirection | TailedAttackArrow | SquadCombat | TailedSquadCombat | GatheringPlace | RectFlag | TriangleFlag | CurveFlag | Rectinclined | Rectinclined_2;

declare namespace PlotUtils {
    export {
        getuuid,
        preventDefault,
        bindAll,
        Point_3 as Point,
        MathDistance,
        wholeDistance,
        getBaseLength,
        Mid,
        getCircleCenterOfThreePoints,
        getIntersectPoint,
        getAzimuth,
        getAngleOfThreePoints,
        isClockWise,
        getPointOnLine,
        getCubicValue,
        getThirdPoint,
        getArcPoints,
        getBisectorNormals,
        getNormal,
        getLeftMostControlPoint,
        getRightMostControlPoint,
        getCurvePoints,
        getBezierPoints,
        getFactorial,
        getBinomialFactor,
        getQBSplinePoints,
        getQuadricBSplineFactor,
        stamp,
        trim,
        splitWords,
        isObject,
        merge
    }
}

declare class PlotUtils_2 {
    map: any;
    ctx: olPlot;
    options: any;
    layerName: string;
    constructor(map: any, options: any, ctx: any);
    /**
     * 获取样式信息
     * @param feature
     * @returns {boolean}
     */
    getBaseStyle(feature: any): any;
    /**
     * 设置点类型的图标样式
     * @param feature
     * @param image
     */
    setIcon(feature: any, image: any): void;
    /**
     * 设置背景颜色
     * @param feature
     * @param backgroundColor
     * @returns {boolean}
     */
    setBackgroundColor(feature: any, backgroundColor: any): void;
    /**
     * 设置透明度
     * @param feature
     * @param opacity
     */
    setOpacity(feature: any, opacity: any): void;
    /**
     * 设置边框颜色
     * @param feature
     * @param borderColor
     */
    setBorderColor(feature: any, borderColor: any): void;
    /**
     * 设置边框宽度
     * @param feature
     * @param borderWidth
     */
    setBorderWidth(feature: any, borderWidth: any): void;
    /**
     * 处理背景色
     * @param color
     * @param opacity
     * @returns {string}
     */
    handleBackgroundColor(color: any, opacity: any): string | undefined;
    /**
     * 获取颜色值
     * @param color
     * @returns {string}
     */
    getColor(color: any): string | undefined;
    /**
     * 去除无值的字段
     * @param obj
     * @returns {*}
     */
    fixObject(obj: any): any;
    /**
     * 获取stroke
     * @param style
     * @returns {*}
     */
    getStroke_(style: any): any;
    /**
     * 获取填充色
     * @param style
     * @returns {*}
     * @private
     */
    getFill_(style: any): any;
    /**
     * 获取文本信息
     * @param style
     * @returns {*}
     * @private
     */
    getText_(style: any): any;
    /**
     * 获取图像信息
     * @param style
     * @returns {*}
     * @private
     */
    getImage_(style: any): any;
    /**
     * 获取样式配置
     * @param feature
     * @returns {{fill: {fillColor: string, opacity: number}, stroke: *, image: *, text: *}}
     */
    getStyleCode(feature: any): {
        fill: {
            fillColor: any;
            opacity: number;
        };
        stroke: any;
        image: any;
        text: any;
    } | undefined;
    /**
     * 移除图层上所有的数据
     */
    removeAllFeatures(): void;
    /**
     * 获取所有的要素包含样式信息的GeoJSON
     * @returns {Array}
     */
    getFeatures(): any[];
    /**
     * 恢复相关标绘
     * @param features
     */
    addFeatures(features: any, featureId?: any, callback?: null): void;
    /**
     * get extent
     * @private
     */
    _getExtent(extents: any, params?: any): any;
    /**
     * 创建删除按钮
     */
    createCloseBtnMark(featureId: any, feature: any, callback: any): void;
    /**
     * 创建删除按钮Overlay标记
     */
    createCloseBtnOverlay(markDom: any, markId: any): Overlay;
    /**
     * 根据FeatureId移除标记(目标特征+删除按钮Overlay)
     */
    removeMarkByFeatureId(featureId: any, callback: any): void;
}

declare class Point extends Point_2 {
    type: PlotTypes;
    fixPointCount: number;
    map: any;
    points: Point_3[];
    freehand: boolean;
    options: any;
    constructor(coordinates: any, point: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    generate(): void;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {{}|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare type Point_3 = [number, number];

declare class Polygon_2 extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class Polyline extends LineString {
    type: PlotTypes;
    fixPointCount: number;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): void;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {ol.Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare function preventDefault(e: any): void;

declare class RectAngle extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    isFill: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): void;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class RectFlag extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 插值点数据
     * @param points
     * @returns {Array}
     */
    calculatePonits(points: any): Point_3[];
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class Rectinclined extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 已知p1，p2，p3三点，计算p3到p1p2的垂直距离
     * @param {*} p1
     * @param {*} p2
     * @param {*} p3
     */
    calculatePerpendicularDistance(p1: any, p2: any, p3: any): number;
    /**
     * 已知p1，p2，两点，判断p3点在p1p2的左右，返回-1右侧，0线上，1左侧
     * @param {*} p1
     * @param {*} p2
     * @param {*} p3
     */
    calculatePositionRelativeToLine(p1: any, p2: any, p3: any): number;
    /**
     * 已知p1，p2，p3点求矩形的p4点
     * @param {*} p1
     * @param {*} p2
     * @param {*} p3
     */
    calculateFourthPoint(p1: any, p2: any, p3: any): Point_3;
    /**
     * 已知p1，p2两点和距离d，求距离p1p2垂直距离为d的点p3
     * @param {*} p1
     * @param {*} p2
     * @param {*} d
     */
    calculatePerpendicularPoint(p1: any, p2: any, d: any): Point_3;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {ol.Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class Rectinclined_2 extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 已知p1，p2，p3点求矩形的p4点
     * @param {*} p1
     * @param {*} p2
     * @param {*} p3
     */
    calculateFourthPoint(p1: any, p2: any, p3: any): Point_3;
    /**
     * 已知p1点和p2点，求p3点到p1p2垂线的交点
     * @param {*} p1
     * @param {*} p2
     * @param {*} p3
     */
    calculateIntersectionPoint(p1: any, p2: any, p3: any): Point_3;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {ol.Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class Sector extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {ol.Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): PlotUtils.Point[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

/**
 * 将类名截取成数组
 * @param str
 */
declare const splitWords: (str: string) => string[];

declare class SquadCombat extends AttackArrow {
    constructor(coordinates: any, points: any, params: any);
    /**
     * 执行动作
     */
    generate(): false | undefined;
    getTailPoints(points: any): PlotUtils.Point[];
}

/**
 * 添加标识
 * @param obj
 * @returns {*}
 */
declare const stamp: (obj: any) => any;

declare class StraightArrow extends LineString {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    maxArrowLength: number;
    arrowLengthScale: number;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {{}|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): PlotUtils.Point[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

declare class StyleFactory {
    style: Style;
    constructor(options: any);
    /**
     * 获取规则样式图形
     * @param options
     * @returns {*}
     * @private
     */
    _getRegularShape(options: any): RegularShape;
    /**
     * 获取图标样式
     * @param options
     * @returns {*}
     * @private
     */
    _getImage(options: any): Icon | RegularShape;
    /**
     * 获取icon
     * @param options
     * @returns {Icon}
     * @private
     */
    _getIcon(options: any): Icon;
    /**
     * 获取线条样式
     * @param options
     * @returns {Stroke}
     * @private
     */
    _getStroke(options: any): Stroke;
    /**
     * 获取样式文本
     * @param options
     * @returns {Text}
     * @private
     */
    _getText(options: any): Text_2;
    /**
     * 获取填充颜色
     * @param options
     * @returns {Fill}
     * @private
     */
    _getFill(options: any): Fill;
}

declare class TailedAttackArrow extends AttackArrow {
    constructor(coordinates: any, points: any, params: any);
    /**
     * 执行动作
     */
    generate(): false | undefined;
}

declare class TailedSquadCombat extends AttackArrow {
    constructor(coordinates: any, points: any, params: any);
    /**
     * 执行动作
     */
    generate(): false | undefined;
    getTailPoints(points: any): PlotUtils.Point[];
}

declare class TriangleFlag extends Polygon {
    type: PlotTypes;
    fixPointCount: WithUndef<number>;
    map: any;
    points: Point_3[];
    freehand: boolean;
    constructor(coordinates: any, points: any, params: any);
    /**
     * 获取标绘类型
     * @returns {*}
     */
    getPlotType(): PlotTypes;
    /**
     * 执行动作
     */
    generate(): false | undefined;
    /**
     * 插值点数据
     * @param points
     * @returns {Array}
     */
    calculatePonits(points: any): Point_3[];
    /**
     * 设置地图对象
     * @param map
     */
    setMap(map: any): void;
    /**
     * 获取当前地图对象
     * @returns {Map|*}
     */
    getMap(): any;
    /**
     * 判断是否是Plot
     * @returns {boolean}
     */
    isPlot(): boolean;
    /**
     * 设置坐标点
     * @param value
     */
    setPoints(value: any): void;
    /**
     * 获取坐标点
     * @returns {Array.<T>}
     */
    getPoints(): Point_3[];
    /**
     * 获取点数量
     * @returns {Number}
     */
    getPointCount(): number;
    /**
     * 更新当前坐标
     * @param point
     * @param index
     */
    updatePoint(point: any, index: any): void;
    /**
     * 更新最后一个坐标
     * @param point
     */
    updateLastPoint(point: any): void;
    /**
     * 结束绘制
     */
    finishDrawing(): void;
}

/**
 * 去除字符串前后空格
 * @param str
 * @returns {*}
 */
declare const trim: (str: string) => string;

/**
 * 计算点集合的总距离
 * @param points
 * @returns {number}
 */
declare const wholeDistance: (points: Point_3[]) => number;

export { }