@openglobus/og 0.28.7 → 1.0.0-rc2

package/lib/entity/{Geometry.d.ts → geometry/Geometry.d.ts}

@@ -1,10 +1,10 @@
-import { Entity } from "./Entity";
-import { Extent } from "../Extent";
+import { Entity } from "../Entity";
+import { Extent } from "../../Extent";
 import { GeometryHandler } from "./GeometryHandler";
-import { Vec4 } from "../math/Vec4";
-import type { NumberArray4 } from "../math/Vec4";
-import type { NumberArray2 } from "../math/Vec2";
-import type { NumberArray3 } from "../math/Vec3";
+import { Vec4 } from "../../math/Vec4";
+import type { NumberArray4 } from "../../math/Vec4";
+import type { NumberArray2 } from "../../math/Vec2";
+import type { NumberArray3 } from "../../math/Vec3";
 export declare enum GeometryTypeEnum {
     POINT = 1,
     LINESTRING = 2,
@@ -91,10 +91,10 @@ declare class Geometry {
     static getType(typeStr: keyof typeof GeometryTypeEnum): GeometryTypeEnum;
     /**
      * Returns geometry extent.
-     @static
-     @param {IGeometry} geometryObj - GeoJSON style geometry feature.
-     @param {IGeometryCoordinates} outCoordinates - Geometry feature coordinates clone.
-     @returns {Extent} -
+     * @static
+     * @param {IGeometry} geometryObj - GeoJSON-style geometry feature.
+     * @param {IGeometryCoordinates} outCoordinates - Cloned geometry coordinates.
+     * @returns {Extent} Geometry extent.
      */
     static getExtent(geometryObj: IGeometry, outCoordinates: IGeometryCoordinates): Extent;
     /**

package/lib/entity/{GeometryHandler.d.ts → geometry/GeometryHandler.d.ts}

@@ -1,10 +1,10 @@
-import { Extent } from "../Extent";
-import { Handler } from "../webgl/Handler";
-import type { WebGLBufferExt } from "../webgl/Handler";
-import { Vector } from "../layer/Vector";
-import { Node } from "../quadTree/Node";
-import { Vec3 } from "../math/Vec3";
-import { Vec4 } from "../math/Vec4";
+import { Extent } from "../../Extent";
+import { Handler } from "../../webgl/Handler";
+import type { WebGLBufferExt } from "../../webgl/Handler";
+import { Vector } from "../../layer/Vector";
+import { Node } from "../../quadTree/Node";
+import { Vec3 } from "../../math/Vec3";
+import { Vec4 } from "../../math/Vec4";
 import type { CoordinatesType, Geometry } from "./Geometry";
 declare class GeometryHandler {
     static __counter__: number;

package/lib/entity/index.d.ts

@@ -1,10 +1,10 @@
-export * from "./Billboard";
+export * from "./billboard/Billboard";
 export * from "./Entity";
 export * from "./EntityCollection";
-export * from "./Geometry";
-export * from "./GeoObject";
-export * from "./Label";
-export * from "./PointCloud";
-export * from "./Polyline";
-export * from "./Ray";
-export * from "./Strip";
+export * from "./geometry/Geometry";
+export * from "./geoObject/GeoObject";
+export * from "./label/Label";
+export * from "./pointCloud/PointCloud";
+export * from "./polyline/Polyline";
+export * from "./ray/Ray";
+export * from "./strip/Strip";

package/lib/entity/{Label.d.ts → label/Label.d.ts}

@@ -1,8 +1,8 @@
-import { BaseBillboard } from "./BaseBillboard";
-import type { IBaseBillboardParams } from "./BaseBillboard";
-import { Vec4 } from "../math/Vec4";
-import type { NumberArray4 } from "../math/Vec4";
-import { FontAtlas } from "../utils/FontAtlas";
+import { BaseBillboard } from "../billboard/BaseBillboard";
+import type { IBaseBillboardParams } from "../billboard/BaseBillboard";
+import { Vec4 } from "../../math/Vec4";
+import type { NumberArray4 } from "../../math/Vec4";
+import { FontAtlas } from "../../utils/FontAtlas";
 import { LabelHandler } from "./LabelHandler";
 export interface ILabelParams extends IBaseBillboardParams {
     text?: string;
@@ -25,7 +25,7 @@ declare const ALIGN: Record<string, number>;
  * @param {number} [options.rotation] - Screen angle rotation.
  * @param {Vec4|string|Array.<number>} [options.color] - Billboard color.
  * @param {Vec3|Array.<number>} [options.alignedAxis] - Billboard aligned vector.
- * @param {Vec3|Array.<number>} [options.offset] - Billboard center screen offset.
+ * @param {Vec2|Array.<number>} [options.offset] - Billboard center screen offset.
  * @param {boolean} [options.visibility] - Visibility.
  * @param {string} [options.text] - Text string.
  * @param {string} [options.face] - HTML5 font face.
@@ -70,8 +70,8 @@ declare class Label extends BaseBillboard {
     protected _outlineColor: Vec4;
     /**
      * Text horizontal align: "left", "right" and "center".
-     * @private
-     * @type {Label.ALIGN}
+     * @protected
+     * @type {number}
      */
     protected _align: number;
     /**
@@ -90,22 +90,21 @@ declare class Label extends BaseBillboard {
     protected _letterSpacing: number;
     constructor(options?: ILabelParams);
     /**
-     * Set label text.
+     * Sets label text.
      * @public
      * @param {string} text - Text string.
-     * It can't be bigger than maximum labelHandler _maxLetters value.
+     * Text length cannot exceed the `labelHandler._maxLetters` value.
      */
     setText(text: string): void;
     /**
-     * Set text letter spacing.
+     * Sets text letter spacing.
      * @public
-     * @param {number} spacing - Letter spacing.
+     * @param {number} letterSpacing - Letter spacing.
      */
     setLetterSpacing(letterSpacing: number): void;
     /**
      * Returns label text letter spacing.
      * @public
-     * @param {number} spacing - Letter spacing.
      */
     getLetterSpacing(): number;
     /**

package/lib/entity/{LabelHandler.d.ts → label/LabelHandler.d.ts}

@@ -1,9 +1,12 @@
 import { Label } from "./Label";
-import { BaseBillboardHandler } from "./BaseBillboardHandler";
-import { EntityCollection } from "./EntityCollection";
-import type { WebGLBufferExt } from "../webgl/Handler";
-import { Vec3 } from "../math/Vec3";
-import { Vec4 } from "../math/Vec4";
+import { BaseBillboardHandler } from "../billboard/BaseBillboardHandler";
+import { EntityCollection } from "../EntityCollection";
+import type { WebGLBufferExt } from "../../webgl/Handler";
+import type { ShaderProgram } from "../../webgl/ShaderProgram";
+import { Vec2 } from "../../math/Vec2";
+import { Vec3 } from "../../math/Vec3";
+import { Vec4 } from "../../math/Vec4";
+import { BaseBillboard } from "../billboard/BaseBillboard";
 type LabelWorkerCallbackData = {
     vertexArr: Float32Array;
     texCoordArr: Float32Array;
@@ -19,6 +22,14 @@ type LabelWorkerCallbackData = {
     outlineColorArr: Float32Array;
     pickingColorArr: Float32Array;
 };
+declare class LabelPassHandler {
+    protected _owner: LabelHandler;
+    protected _isOutlinePass: boolean;
+    constructor(owner: LabelHandler, isOutlinePass: boolean);
+    drawOpaque(): void;
+    drawTransparent(): void;
+    drawTransparentForward(): void;
+}
 declare class LabelHandler extends BaseBillboardHandler {
     protected _billboards: Label[];
     protected _gliphParamBuffer: WebGLBufferExt | null;
@@ -29,6 +40,8 @@ declare class LabelHandler extends BaseBillboardHandler {
     protected _fontIndexArr: Float32Array;
     protected _outlineArr: Float32Array;
     protected _outlineColorArr: Float32Array;
+    fillLabelHandler: LabelPassHandler;
+    outlineLabelHandler: LabelPassHandler;
     _maxLetters: number;
     constructor(entityCollection: EntityCollection, maxLetters?: number);
     initProgram(): void;
@@ -38,16 +51,27 @@ declare class LabelHandler extends BaseBillboardHandler {
     protected _addLabelToArrays(label: Label): void;
     assignFontAtlas(label: Label): void;
     workerCallback(data: LabelWorkerCallbackData, label: Label): void;
+    protected _isBillboardOpaque(billboard: BaseBillboard): boolean;
+    protected _swapBillboardData(firstIndex: number, secondIndex: number): void;
     clear(): void;
     protected _deleteBuffers(): void;
-    _displayPASS(): void;
+    protected _getOpaqueProgram(): ShaderProgram;
+    protected _getTransparentProgram(): ShaderProgram;
+    drawOpaque(): void;
+    drawTransparent(): void;
+    drawTransparentForward(): void;
+    drawPass(isOutlinePass: boolean, opaquePass: boolean, drawInForward?: boolean): void;
+    protected _displayOutlinePASS(startBillboardIndex: number, endBillboardIndex: number, labelProgram: ShaderProgram): void;
+    protected _displayFillPASS(startBillboardIndex: number, endBillboardIndex: number, labelProgram: ShaderProgram): void;
+    protected _drawLabelPass(startBillboardIndex: number, endBillboardIndex: number, labelProgram: ShaderProgram, isOutlinePass: boolean, depthWrite?: boolean): void;
+    protected _displayPASS(startBillboardIndex: number, endBillboardIndex: number, labelProgram: ShaderProgram): void;
     protected _pickingPASS(): void;
     protected _removeBillboard(label: Label): void;
     setText(index: number, text: string, fontIndex: number, align: number, letterSpacing?: number, isRTL?: boolean): void;
     setPositionArr(index: number, positionHigh: Vec3, positionLow: Vec3): void;
     setPickingColorArr(index: number, color: Vec3): void;
     setSizeArr(index: number, size: number): void;
-    setOffsetArr(index: number, offset: Vec3): void;
+    setOffsetArr(index: number, offset: Vec2): void;
     setRgbaArr(index: number, rgba: Vec4): void;
     setOutlineColorArr(index: number, rgba: Vec4): void;
     setOutlineArr(index: number, outline: number): void;

package/lib/entity/{LabelWorker.d.ts → label/LabelWorker.d.ts}

@@ -1,6 +1,6 @@
-import { BaseWorker } from "../utils/BaseWorker";
-import { Label } from "../entity/Label";
-import { LabelHandler } from "../entity/LabelHandler";
+import { BaseWorker } from "../../utils/BaseWorker";
+import { Label } from "./Label";
+import { LabelHandler } from "./LabelHandler";
 export declare const LOCK_UPDATE = -2;
 export declare const LOCK_FREE = -1;
 interface LabelInfo {

package/lib/entity/{PointCloud.d.ts → pointCloud/PointCloud.d.ts}

@@ -1,10 +1,10 @@
-import { Entity } from "./Entity";
+import { Entity } from "../Entity";
 import { PointCloudHandler } from "./PointCloudHandler";
-import { RenderNode } from "../scene/RenderNode";
-import { Vec3 } from "../math/Vec3";
-import { Vec4 } from "../math/Vec4";
-import type { WebGLBufferExt } from "../webgl/Handler";
-import { EntityCollection } from "./EntityCollection";
+import { Scene } from "../../scene/Scene";
+import { Vec3 } from "../../math/Vec3";
+import { Vec4 } from "../../math/Vec4";
+import type { WebGLBufferExt } from "../../webgl/Handler";
+import { EntityCollection } from "../EntityCollection";
 export interface IPointCloudParams {
     visibility?: boolean;
     pointSize?: number;
@@ -66,9 +66,9 @@ declare class PointCloud {
     /**
      * Parent collection render node.
      * @protected
-     * @type {RenderNode | null}
+     * @type {Scene | null}
      */
-    protected _renderNode: RenderNode | null;
+    protected _scene: Scene | null;
     /**
      * Entity instance that holds this point cloud.
      * @public
@@ -124,15 +124,21 @@ declare class PointCloud {
      */
     setVisibility(visibility: boolean): void;
     /**
-     * @return {boolean} Point cloud visibility.
+     * Sets opacity for all points in the cloud.
+     * @public
+     * @param {number} opacity - Opacity value in range [0..1].
+     */
+    setOpacity(opacity: number): void;
+    /**
+     * @returns {boolean} Point cloud visibility.
      */
     getVisibility(): boolean;
     /**
      * Assign rendering scene node.
      * @public
-     * @param {RenderNode}  renderNode - Assigned render node.
+     * @param {Scene}  scene - Assigned render node.
      */
-    setRenderNode(renderNode: RenderNode): void;
+    bindScene(scene: Scene): void;
     /**
      * Removes from entity.
      * @public
@@ -154,7 +160,7 @@ declare class PointCloud {
      * Returns specific point by index.
      * @public
      * @param {number} index - Point index.
-     * @return {Poi} Specific point
+     * @returns {IPoint} Point at the given index.
      */
     getPoint(index: number): IPoint;
     removePoint(index: number): void;

package/lib/entity/{PointCloudHandler.d.ts → pointCloud/PointCloudHandler.d.ts}

@@ -1,7 +1,7 @@
-import { EntityCollection } from "./EntityCollection";
+import { EntityCollection } from "../EntityCollection";
 import { PointCloud } from "./PointCloud";
-import { Renderer } from "../renderer/Renderer";
-import { RenderNode } from "../scene/RenderNode";
+import { Renderer } from "../../renderer/Renderer";
+import { Scene } from "../../scene/Scene";
 declare class PointCloudHandler {
     static __counter__: number;
     protected __id: number;
@@ -31,7 +31,7 @@ declare class PointCloudHandler {
     protected _pointClouds: PointCloud[];
     constructor(entityCollection: EntityCollection);
     protected _initProgram(): void;
-    setRenderNode(renderNode: RenderNode): void;
+    bindScene(scene: Scene): void;
     add(pointCloud: PointCloud): void;
     remove(pointCloud: PointCloud): void;
     protected _reindexPointCloudArray(startIndex: number): void;

package/lib/entity/polyline/Polyline.d.ts

@@ -0,0 +1,242 @@
+import { Entity } from "../Entity";
+import { LonLat } from "../../LonLat";
+import { Vec3 } from "../../math/Vec3";
+import type { NumberArray3 } from "../../math/Vec3";
+import type { NumberArray2 } from "../../math/Vec2";
+import type { NumberArray4 } from "../../math/Vec4";
+import type { HTMLImageElementExt } from "../../utils/ImagesCacheManager";
+import { PolylineHandler } from "./PolylineHandler";
+import { PolylineBatchRenderer } from "./PolylineBatchRenderer";
+import { Extent } from "../../Extent";
+export type Geodetic = LonLat | NumberArray2 | NumberArray3;
+export type Cartesian = Vec3 | NumberArray3;
+export type SegmentPath3vExt = Cartesian[];
+export type SegmentPathLonLatExt = Geodetic[];
+export type SegmentPathColor = NumberArray4[];
+export type SegmentPath3v = Vec3[];
+export type SegmentPathLonLat = LonLat[];
+export interface TexParam {
+    texOffset: number;
+    strokeSize: number;
+    texOffsetSpeed: number;
+}
+type StrokeSource = string | HTMLImageElement | null;
+export interface IPolylineParams {
+    altitude?: number;
+    thickness?: number;
+    opacity?: number;
+    color?: string | string[];
+    visibility?: boolean;
+    isClosed?: boolean;
+    pathColors?: SegmentPathColor[];
+    path3v?: SegmentPath3vExt[];
+    pathLonLat?: SegmentPathLonLatExt[];
+    src?: StrokeSource;
+    texParams?: Partial<TexParam>;
+}
+/**
+ * Polyline object.
+ * @class
+ * @param {Object} [options] - Polyline options:
+ * @param {number} [options.thickness] - Thickness in screen pixels 1.5 is default.
+ * @param {Number} [options.altitude] - Relative to ground layers altitude value.
+ * @param {string|string[]} [options.color] - Default line color or per-segment HTML colors.
+ * @param {Boolean} [options.opacity] - Line opacity.
+ * @param {Boolean} [options.visibility] - Polyline visibility. True default.
+ * @param {Boolean[]} [options.isClosed] - Closed geometry type identification, per-segment.
+ * @param {SegmentPathLonLatExt[]} [options.pathLonLat] - Polyline geodetic coordinates array. [[[0,0,0], [1,1,1],...]]
+ * @param {SegmentPath3vExt[]} [options.path3v] - LinesString cartesian coordinates array. [[[0,0,0], [1,1,1],...]]
+ * @param {SegmentPathColor[]} [options.pathColors] - Coordinates color. [[[1,0,0,1], [0,1,0,1],...]] for right and green colors.
+ * @param {TexParam} [options.texParams] - Texture params for all segments: texOffset, strokeSize and texOffsetSpeed.
+ */
+declare class Polyline {
+    static __counter__: number;
+    protected __id: number;
+    _entity: Entity | null;
+    _extent: Extent;
+    _handler: PolylineHandler | null;
+    _handlerIndex: number;
+    _batchRenderer: PolylineBatchRenderer | null;
+    _batchRendererIndexes: number[];
+    _path3v: SegmentPath3vExt[];
+    protected _pathLonLat: SegmentPathLonLatExt[];
+    protected _pathColors: SegmentPathColor[];
+    protected _color: string[];
+    protected _segmentTexParams: Partial<TexParam> | null;
+    protected _src: StrokeSource;
+    protected _isClosed: boolean;
+    protected _visibility: boolean;
+    protected _image: HTMLImageElement | null;
+    protected _opacity: number;
+    protected _thickness: number;
+    protected _altitude: number;
+    protected _pickingColor: Vec3 | null;
+    constructor(options?: IPolylineParams);
+    get _pathLonLatMerc(): LonLat[][];
+    protected _pathLonLatMercFromLocal(): LonLat[][];
+    set altitude(alt: number);
+    get altitude(): number;
+    _addToBatchRenderer(): void;
+    _removeFromBatchRenderer(): void;
+    protected _getDefaultHtmlColor(segmentIndex?: number): string | undefined;
+    protected _getDefaultPathColor(segmentIndex?: number): NumberArray4 | undefined;
+    protected _applySegmentProps(batchIndex: number, segmentIndex?: number): void;
+    protected _tryAddSegmentToBatch(segmentIndex: number): boolean;
+    protected _updateExtent(): void;
+    getExtent(): Extent;
+    getPath3v(): SegmentPath3vExt[];
+    getPathLonLat(): SegmentPathLonLatExt[];
+    getPathColors(): NumberArray4[][];
+    setImage(image: HTMLImageElement): void;
+    getImage(): HTMLImageElementExt | null;
+    /**
+     * Sets stroke source per segment (null = color-only).
+     * @public
+     */
+    setSrc(src: StrokeSource): void;
+    getSrc(): StrokeSource;
+    /**
+     * Sets closed/open state for one path segment.
+     * @public
+     */
+    set isClosed(isClosed: boolean);
+    get isClosed(): boolean;
+    setTextureDisabled(): void;
+    static setPathColors(pathLonLat: SegmentPathLonLatExt[], pathColors: SegmentPathColor[], defaultColor: NumberArray4, outColors: number[]): void;
+    setPointLonLat(lonlat: LonLat, index: number, segmentIndex: number): void;
+    /**
+     * Changes cartesian point coordinates of the path
+     * @param {Vec3} coordinates - New coordinates
+     * @param {number} [index=0] - Path segment index
+     * @param {number} [segmentIndex=0] - Index of the point in the path segment
+     * @param {boolean} [skipLonLat=false] - Do not update geodetic coordinates
+     */
+    setPoint3v(coordinates: Vec3, index?: number, segmentIndex?: number, skipLonLat?: boolean): void;
+    /**
+     * Remove point from the path
+     * @param {number} index - Point index in a path segment
+     * @param {number} [segmentIndex=0] - Segment path index
+     */
+    removePoint(index: number, segmentIndex?: number): void;
+    /**
+     * Insert point coordinates in a path segment
+     * @param {Vec3} point3v - Point coordinates
+     * @param {number} [index=0] - Index in the path
+     * @param {NumberArray4} [color] - Point color
+     * @param {number} [segmentIndex=0] - Path segment index
+     */
+    insertPoint3v(point3v: Vec3, index?: number, color?: NumberArray4, segmentIndex?: number): void;
+    /**
+     * Append new point in the end of the path.
+     * @public
+     * @param {Vec3} point3v - New point coordinates.
+     * @param {number} [segmentIndex=0] - Path segment index, first by default.
+     * @param {NumberArray4} [color] - Point color
+     */
+    addPoint3v(point3v: Vec3, segmentIndex?: number, color?: NumberArray4): void;
+    /**
+     * Append new geodetic point in the end of the path.
+     * @public
+     * @param {LonLat} lonLat - New coordinate.
+     * @param {number} [segmentIndex=0] - Path segment index, first by default.
+     * @param {NumberArray4} [color] - Point color.
+     */
+    addPointLonLat(lonLat: LonLat, segmentIndex?: number, color?: NumberArray4): void;
+    /**
+     * Change path point color
+     * @param {NumberArray4} color - New color
+     * @param {number} [index=0] - Point index
+     * @param {number} [segmentIndex=0] - Path segment index
+     */
+    setPointColor(color: NumberArray4, index?: number, segmentIndex?: number): void;
+    /**
+     * Remove multiline path segment
+     * @param {number} index - Segment index in multiline
+     */
+    removePath(index: number): void;
+    appendPath3v(path3v: SegmentPath3vExt, pathColors?: NumberArray4[]): void;
+    appendPathLonLat(pathLonLat: SegmentPathLonLatExt): void;
+    setPathLonLatFast(pathLonLat: SegmentPathLonLatExt[], pathColors?: (SegmentPathColor | NumberArray4)[] | SegmentPathColor | NumberArray4): void;
+    setPath3vFast(path3v: SegmentPath3vExt[], pathColors?: (SegmentPathColor | NumberArray4)[] | SegmentPathColor | NumberArray4): void;
+    /**
+     * Sets Polyline cartesian coordinates.
+     * @public
+     * @param {SegmentPath3vExt[]} path3v - Polyline path cartesian coordinates. (exactly 3 entries)
+     * @param {SegmentPathColor[]} [pathColors] - Polyline path cartesian coordinates. (exactly 3 entries)
+     * @param {Boolean} [forceEqual=false] - Makes assigning faster for size equal coordinates array.
+     */
+    setPath3v(path3v: SegmentPath3vExt[], pathColors?: (SegmentPathColor | NumberArray4)[], forceEqual?: boolean): void;
+    setPath3v(path3v: SegmentPath3vExt, pathColors?: SegmentPathColor | NumberArray4, forceEqual?: boolean, segmentIndex?: number): void;
+    /**
+     * Sets polyline geodetic coordinates.
+     * @public
+     * @param {SegmentPathLonLat[]} pathLonLat - Polyline path cartesian coordinates.
+     * @param {SegmentPathColor[]} pathColors - Polyline path points colors.
+     * @param {Boolean} [forceEqual=false] - OPTIMIZATION FLAG: Makes assigning faster for size equal coordinates array.
+     */
+    setPathLonLat(pathLonLat: SegmentPathLonLatExt[], pathColors?: (SegmentPathColor | NumberArray4)[], forceEqual?: boolean): void;
+    setPathLonLat(pathLonLat: SegmentPathLonLatExt, pathColors?: SegmentPathColor | NumberArray4, forceEqual?: boolean, segmentIndex?: number): void;
+    /**
+     * Sets polyline opacity.
+     * @public
+     * @param {number} opacity - Opacity.
+     */
+    setOpacity(opacity: number): void;
+    /**
+     * Gets polyline opacity.
+     * @public
+     */
+    getOpacity(): number;
+    /**
+     * Sets Polyline thickness in screen pixels.
+     * @public
+     * @param {number} altitude - ALtitude value.
+     */
+    setAltitude(altitude: number): void;
+    /**
+     * Sets Polyline thickness in screen pixels.
+     * @public
+     * @param {number} thickness - Thickness.
+     */
+    setThickness(thickness: number): void;
+    /**
+     * Sets polyline segment color.
+     * @public
+     * @param {string} htmlColor - HTML color.
+     */
+    setColor(htmlColor: string): void;
+    setPathTexOffset(texOffset: number, segmentIndex: number): void;
+    setPathStrokeSize(strokeSize: number, segmentIndex: number): void;
+    setPathTexOffsetSpeed(texOffsetSpeed: number, segmentIndex: number): void;
+    /**
+     * Sets visibility.
+     * @public
+     * @param {boolean} visibility - Polyline visibility.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * Gets Polyline visibility.
+     * @public
+     * @returns {boolean} Polyline visibility.
+     */
+    getVisibility(): boolean;
+    setPickingColor3v(color: Vec3): void;
+    setPathColors(pathColors: SegmentPathColor[]): void;
+    setPathColors(pathColors: SegmentPathColor, segmentIndex: number): void;
+    /**
+     * Sets polyline color
+     * @param {string} htmlColor - HTML color.
+     */
+    setColorHTML(htmlColor: string): void;
+    /**
+     * Clear polyline data.
+     * @public
+     */
+    clear(): void;
+    /**
+     * Removes from an entity.
+     * @public
+     */
+    remove(): void;
+}
+export { Polyline };