ts/public/GV/GEOVIS.d.ts

25661 lines
659 KiB
TypeScript
Raw Normal View History

2024-12-09 06:44:52 +00:00
declare module GV { class Subject<T> {}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#airborneAnalysis'></a>
*/
class AirborneAnalysis {
private viewer;
private polygon;
private labelArr;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* polygonColor
* textColor
* depthTest
*/
open(data: any, polygonColor?: string, textColor?: string, depthTest?: boolean): void;
/**
*
*/
close(): void;
/**
*
*/
getAirBorne(): number;
}
/**
* @类型 使
* @描述
*/
class Analysis {
private _viewer;
private _layerSplit;
private _viewshedAnalyze;
private _heightAnalyze;
private _groundClip;
private _floodAnalysis;
private _profileAnalysis;
private _measureDistance;
private _measureArea;
private _hideAnalysis;
private _intervisibilityAnalysis;
private _pathAnalysis;
private _polygonVisiableAnalysis;
private _slopeAnalysis;
private _skylineAnalyze;
private _bufferAnalysis;
private _headFloodAnalysis;
private _shadowAnalysis;
private _watchHouseAnalysis;
private _contourAnalysis;
private _directAimAnalysis;
private _inDirectAimAnalysis;
private _airborneAnalysis;
private _groundClippingAnalysis;
private _nuclearProtectionAnalysis;
private _morphologicAnalysis;
constructor(viewer: GeoCanvas);
private _init;
/**
*
*/
readonly layerSplit: LayerSplit;
/**
* @see <a href='../../../examples/gallery/editor.html#intervisibilityAnalysis'></a>
*/
readonly viewshedAnalyze: ViewshedAnalyze;
/**
*
*/
readonly heightAnalyze: HeightAnalyze;
readonly groundClip: GroundClipping;
/**
*
*/
readonly floodAnalysis: FloodAnalysis;
/**
*
*/
readonly profileAnalysis: ProfileAnalysis;
/**
*
*/
readonly measureDistance: MeasureDistance;
/**
*
*/
readonly measureArea: MeasureArea;
/**
*
*/
readonly hideAnalysis: HideAnalysis;
/**
*
*/
readonly intervisibilityAnalysis: IntervisibilityAnalysis;
/**
*
*/
readonly pathAnalysis: PathAnalysis;
/**
*
*/
readonly polygonVisiableAnalysis: PolygonVisiableAnalysis;
/**
*
*/
readonly slopeAnalysis: SlopeAnalysis;
/**
* 线
*/
readonly SkylineAnalyze: SkylineAnalyze;
/**
*
*/
readonly bufferAnalysis: BufferAnalysis;
/**
*
*/
readonly headFloodAnalysis: HeadFloodAnalysis;
/**
*
*/
readonly shadowAnalysis: ShadowAnalysis;
/**
*
* @readonly
*/
readonly watchHouseAnalysis: WatchHouseAnalysis;
/**
* 线
*/
readonly contourAnalysis: ContourAnalysis;
/**
*
*/
readonly directAimAnalysis: DirectAimAnalysis;
/**
*
*/
readonly inDirectAimAnalysis: InDirectAimAnalysis;
/**
*
*/
readonly airborneAnalysis: AirborneAnalysis;
/**
*
*/
readonly groundClippingAnalysis: GroundClippingAnalysis;
/**
*
*/
readonly nuclearProtectionAnalysis: NuclearProtectionAnalysis;
/**
*
*/
readonly morphologicAnalysis: MorphologicAnalysis;
}
class AnalysisUtil {
/**
*
* @param width
* @param height
* @param color
*/
static createImage(width: number, height: number, color: Array<number>): string;
static createPolyline(data: Array<Array<GeoPoint>>, lineWidth?: number, color?: string): any;
static createPolygon(data: Array<Array<GeoPoint>>, color?: string, imageSrc?: string): Cesium.GroundPrimitive;
static createTextPoint(pos: GeoPoint, text: string, textColor?: string): Cesium.Entity;
static createRectangle(rect: Cesium.Rectangle, src: string): Cesium.Entity;
static createPoint(pos: GeoPoint, color?: string): Cesium.Entity;
static createLine(posArr: Array<GeoPoint>, color?: string, lineWidth?: number): Cesium.Entity;
static createEllipse(dis: number, position: GeoPoint, src: string): Cesium.Entity;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#bufferAnalysis'></a>
*/
class BufferAnalysis {
private viewer;
private dataSource;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* depthTest
* color
*/
open(data: any, depthTest?: boolean, color?: string): void;
/**
*
*/
close(): void;
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#contourAnalysis'>线</a>
*/
class ContourAnalysis {
private viewer;
private primitive;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* color 线
* lineWidth 线
*/
open(data: any, color?: string, lineWidth?: number): void;
/**
*
*/
close(): void;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#directAimAnalysis'></a>
*/
class DirectAimAnalysis {
private viewer;
private rectangle;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* rangeOutColor
* invisibleColor
* unbeatColor
* beatColor
* depthTest
*/
open(data: any, rangeOutColor?: string, invisibleColor?: string, unbeatColor?: string, beatColor?: string, depthTest?: boolean): void;
/**
*
*/
close(): void;
}
/**
* @类型 使
* @描述 Analysis
* @see <a href='../../../examples/gallery/editor.html#floodAnalysisFont'></a>
*/
class FloodAnalysis {
private _viewer;
private _handler;
private _polygon;
private _flag;
private _point;
private _label;
private _rect;
private _clampToGround;
private _area;
private _labelItem;
constructor(viewer: any);
/**
*
* @param unit
* @param color
*/
open(opt: FloodAnalysisOpt): void;
/**
*
* @param data
* @param color
*/
private _selectBsaePoint;
private _calcDistance;
/**
*
*/
close(): void;
}
/**
*
*/
class FloodAnalysisOpt {
/**
*
*/
clampToGround: true;
/**
* 线
*/
color: ColorStyle;
/**
*
*/
unit: string;
/**
* 线
*/
width: number;
/**
*
*/
labelGraphicOpt?: LabelGraphicOpt;
/**
*
*/
finshCallback?: Function;
}
/**
*
*/
class GroundClipping {
/**
*
*/
viewer: GeoCanvas;
/**
*
*/
private terrainClipPlan;
private _path;
/**
*
*/
path: Array<GeoPoint>;
private _height;
/**
*
*/
height: number;
/**
*
* @param viewer
*/
constructor(viewer: any);
/**
*
* @param path
* @param height
* @param wallImg
* @param bottomImg
*/
add(path: Array<GeoPoint>, height?: number): void;
/**
*
* @param path
*/
private getPositionsData;
/**
*
*/
private updateData;
/**
*
*/
clear(): void;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#groundClippingAnalysis'></a>
*/
class GroundClippingAnalysis {
private viewer;
private entityArr;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* wafangLevel
* pointList ,
*/
open(data: any, wafangLevel: number, pointList: Array<GeoPoint>): void;
/**
*
*/
close(): void;
/**
*
*/
private getFlatternDistance;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#headFloodAnalysis'></a>
*/
class HeadFloodAnalysis {
private viewer;
private rectangle;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* depthTest
* floodColor
* noFloodColor
*/
open(data: any, depthTest?: boolean, floodColor?: string, noFloodColor?: string): void;
/**
*
*/
close(): void;
private createMap;
}
/**
* @类型 使
* @描述 Analysis
* @see <a href='../../../examples/gallery/editor.html#heightAnalyze'></a>
*/
class HeightAnalyze {
viewer: any;
config: any;
_layer: any;
_points: any[];
/**
*
* @method constructor
* @param viewer Cesium.Viewer
*
*/
constructor(viewer: any);
color: any;
/**
* @method height
*
*
*
* ```
* var heightAnalyze = viewer.analysis.heightAnalyze;
* heightAnalyze.height = 400;
* heightAnalyze.open();
* ```
*
*/
height: number;
/**
*
* @method setPolygon
* @param points :[,,]
*
* ```
* var heightAnalyze = viewer.analysis.heightAnalyze;
* heightAnalyze.height = 400;
* heightAnalyze.setPolygon([
* 109.0349381448271,34.31717633782572,386.9231637517154,109.03900961665003,
* 34.321847375754345,397.67154065059685,
* 109.03346632153671,34.326639657406226,395.4792360496345,
* 109.03144059631933,34.32489928901451,390.96019381390937,
* 109.0311066948082,34.323485025163286,388.67673695624234,
* 109.03229719685534,34.31991103654269,385.82666822350035,
* 109.03358048811168,34.31842706237503,386.4791369856086,
* 109.03433018158603,34.31771892610954,387.5863231772101
* ]);
* heightAnalyze.open();
* ```
*
*/
setPolygon(points: Array<Number>): void;
/**
*
* @method open
* @return
*/
open(): void;
/**
*
* @method close
*/
close(): void;
private updateLayer;
private creategeometry;
}
/**
*
*/
class HideAnalysis {
private viewer;
private entity;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* center
* dis
* depthTest
* hideColor
* noHideColor
*/
open(data: any, center: GeoPoint, dis: number, depthTest?: boolean, hideColor?: string, noHideColor?: string): void;
/**
*
*/
close(): void;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#indirectAimAnalysis'></a>
*/
class InDirectAimAnalysis {
private viewer;
private rectangle;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* unbeatColor
* beatColor
* depthTest
*/
open(data: any, unbeatColor?: string, beatColor?: string, depthTest?: boolean): void;
/**
*
*/
close(): void;
}
/**
*
*/
class IntervisibilityAnalysis {
private viewer;
private lineGreen;
private lineRed;
private dirLine;
private point;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* posArr []
* lineWidth 线
* depthTest
* visableColor 线
* invisableColor
* obstructPointColor
*/
open(data: any, posArr: Array<GeoPoint>, depthTest?: boolean, lineWidth?: number, visableColor?: string, invisableColor?: string, obstructPointColor?: string): void;
/**
*
*/
private createObstructPrimitive;
/**
*
*/
private createDirPrimitive;
/**
*
*/
close(): void;
}
/**
*
*/
class LayerSplit {
private _layer;
private _viewer;
private _type;
private _handler;
/**
*
* @param viewer
* @param layer
* @param type
* @param style
*/
constructor(viewer: GeoCanvas);
private _getType;
private _formatCss;
private _main;
/**
*
* @param {Cesium.ImageryLayer} layer
* @param {string} type ['left','right','up','bottom']
* @param {string} barColor
* @param {number} barWidth
*/
open(layer: Cesium.ImageryLayer, type?: string, barColor?: string, barWidth?: number): void;
/**
*
*/
close(): void;
}
/**
*
*/
class MeasureArea {
private _viewer;
private _area;
private _clampToGround;
private _ploygon;
private _labelItem;
constructor(viewer: Cesium.Viewer);
/**
*
* @param clampToGround
* @param unit meter kilometer
* @param color
* @param labelGraphicOpt
* @param finshCallback
*/
open(areaOpt: MeasureAreaOpt): void;
private _calcDistance;
/**
*
*/
close(): void;
}
class MeasureAreaOpt {
/**
*
*/
clampToGround: boolean;
/**
* 线
*/
polygonClamp: boolean;
/**
* meter kilometer
*/
unit: string;
/**
* 线
*/
color: string;
/**
*
*/
labelGraphicOpt?: LabelGraphicOpt;
/**
*
*/
finshCallback?: Function;
}
/**
*
*/
class MeasureDistance {
private _viewer;
private _distance;
private _clampToGround;
private _polyline;
private _labelItem;
constructor(viewer: Cesium.Viewer);
/**
*
* @param disopt
*/
open(disopt: MeasureDistanceOpt): void;
private _calcDistance;
/**
*
*/
close(): void;
}
class MeasureDistanceOpt {
/**
*
*/
clampToGround: boolean;
/**
* 线
*/
lineClamp: boolean;
/**
* meter kilometer
*/
unit: string;
/**
* 线
*/
color: string;
/**
*
*/
labelGraphicOpt?: LabelGraphicOpt;
/**
*
*/
finshCallback?: Function;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#morphologicAnalysis'></a>
*/
class MorphologicAnalysis {
private viewer;
private entitiyArr;
private primitiveArr;
constructor(viewer: GeoCanvas);
/**
*
* @param data response.data
* @param radioModel
* @param position
* @param lineColor 线
* @param textColor
* @param depthTest
*/
open(data: any, radioModel: MorphologicModelEnum, position?: Array<GeoPoint>, lineColor?: string, textColor?: string, depthTest?: boolean): void;
/**
*
*/
close(): void;
}
/**
*
*/
enum MorphologicModelEnum {
/**山顶点 */
'MountainTop' = 1,
/**鞍部点 */
'Saddlepoint' = 2,
/**山脚线 */
'Bottomline' = 3,
/**山谷线 */
'Valleyline' = 4,
/**山脊线 */
'Ridgeline' = 5,
/**地貌类型 */
'TerrainType' = 6
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#nuclearProtectionAnalysis'></a>
*/
class NuclearProtectionAnalysis {
private viewer;
private entity;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* depthTest
*/
open(data: any, depthTest?: boolean): void;
/**
*
*/
close(): void;
}
/**
*
*/
class PathAnalysis {
/**
*
*/
private viewer;
private pathArr;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* depthTest
* lineWidth 线
* color 线
*/
open(data: any, depthTest?: boolean, lineWidth?: number, color?: string): void;
/**
*
*/
close(): void;
}
/**
*
*/
class PolygonVisiableAnalysis {
private viewer;
private entity;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* depthTest
* visiableColor
* invisibleColor
*/
open(data: any, depthTest?: boolean, visiableColor?: string, invisibleColor?: string): void;
/**
*
*/
close(): void;
}
/**
*
*/
class ProfileAnalysis {
private _viewer;
private _measureDistance;
constructor(viewer: any);
/**
*
* @param callback
*/
open(callback: Function): void;
/**
*
*/
close(): void;
}
/**
* @author zhuwz
* @desc 3DTiles
*/
class SelectionTool {
private _tileet;
private _selectionColor;
constructor(tileet: Cesium.Cesium3DTileset);
/**
*
*/
selectionColor: Cesium.Color;
/**
*
* @param propertyName
* @param propertyValus
*/
select(propertyName: string, propertyValus: Array<string>): void;
/**
*
*
*/
clear(): void;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#shadowAnalysis'></a>
*/
class ShadowAnalysis {
private viewer;
private rectangle;
constructor(viewer: GeoCanvas);
/**
*
*/
close(): void;
/**
*
* data response.data
* depthTest
*/
open(data: any, depthTest?: boolean): void;
private createMap;
}
/**
* @类型 使
* @描述 线 Analysis
* @see <a href='../../../examples/gallery/editor.html#skylineAnay'>线</a>
*/
class SkylineAnalyze {
private _skylinePostProcess;
private _viewer;
private _psLayer;
constructor(viewer: any);
/**
* 线
* @param opt 线
*/
open(opt: SkylineOption): void;
/**
* 线
*/
close(): void;
}
class SkylineOption {
/**
* 线
*/
width: number;
strokeType: Cesium.Cartesian3;
bjColor: Cesium.Color;
color: Cesium.Color;
strokeDistance: number;
}
class SkylinePostProcess extends Cesium.PostProcessStage {
constructor(camera: Cesium.Camera, opts: SkylineOption);
}
/**
*
* 9,
* level_1:rgba(45,136,4,1.0),
* level_2:rgba(75,153,4,1.0),
* level_3:rgba(111,169,4,1.0),
* level_4:rgba(154,188,4,1.0),
* level_5:rgba(204,206,4,1.0),
* level_6:rgba(204,155,4,1.0),
* level_7:rgba(204,104,4,1.0),
* level_8:rgba(204,53,4,1.0),
* level_9:rgba(204,2,4,1.0)
*/
class SlopeAnalysis {
private viewer;
private rectangle;
constructor(viewer: GeoCanvas);
/**
*
* data response.data
* depthTest
*/
open(data: any, depthTest?: boolean): void;
/**
* UV
* @param res
*/
private createMap;
/**
*
*/
close(): void;
}
class TerrainClipPlane {
viewer: GeoCanvas;
bottomSurface: any;
wellWall: any;
private options;
private _positions;
private _height;
height: number;
wallImg: String;
bottomImg: String;
private splitNum;
private excavateMinHeight;
private wellData;
private _show;
show: any;
constructor(t: any, i: any);
updateData(e: any): void;
private _prepareWell;
private _createWell;
private _getMinHeight;
private _ellipsoidToLonLat;
private _createWellWall;
private _createBottomSurface;
private _switchExcavate;
private _updateExcavateDepth;
/**
*
*/
clear(): void;
}
/**
*
*/
class ViewshedAnalyze {
viewer: any;
config: any;
defaultOption: any;
/**
*
* @method constructor
* @param viewer Cesium.Viewer
*
*/
constructor(viewer: Cesium.Viewer);
VisibleColor: any;
InVisibleColor: any;
/**
*
*
*/
showDistance: any;
/**
*
* @method start
*
*/
open(): void;
/**
*
* @method stop
*
*/
close(): void;
_initialiseHandlers(): void;
_addEntity(pos: any): void;
_calculatePose(pickingPos: any): void;
_createViewShad(pos: any): void;
_getUIShader(self: any, fs: any, shadowMap: any, castShadows: any, isTerrain: any, hasTerrainNormal: any): any;
_updateLightDirection(): void;
_creatFrustum(): void;
_pickPosition(winPosition: any): any;
_getViewShadGeometry(frustumGeometry: any): any;
}
class ViewShedPrimitive {
viewer: any;
cameraPosition: any;
_horizontalAngle: any;
viewPosition: any;
_verticalAngle: any;
_visibleAreaColor: any;
_hiddenAreaColor: any;
_alpha: any;
_distance: any;
_frustum: any;
calback: any;
frustumQuaternion: any;
_handler: any;
radar: any;
viewShadowMap: any;
pCamera: any;
postProcess: any;
constructor(viewer: any, option: any);
readonly config: {
cameraPosition: any;
viewPosition: any;
horizontalAngle: number;
verticalAngle: number;
visibleAreaColor: Cesium.Color;
hiddenAreaColor: Cesium.Color;
alpha: number;
distance: number;
frustum: boolean;
};
getCurrentMousePosition(e: any, t: any, testParms: any): any;
validate(e: any, t: any): boolean;
_bindMourseEvent(): void;
_unbindMourseEvent(): void;
_addToScene(): void;
_createShadowMap(cPosition: any, vPosition: any): void;
getFrustumQuaternion(position: any, viewPosition: any): Cesium.HeadingPitchRoll;
_addPostProcess(): void;
removeRadar(): void;
resetRadar(): void;
addRadar(position: any, hpr: any): void;
update(e: any): void;
destroy(): void;
horizontalAngle: any;
verticalAngle: any;
distance: any;
visibleAreaColor: any;
hiddenAreaColor: any;
alpha: any;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#WatchHouseAnalysis'></a>
*/
class WatchHouseAnalysis {
private viewer;
private rectangle;
private watchEntity;
private iconEntityArr;
constructor(viewer: GeoCanvas);
/**
*
* @param data response.data
*/
open(data: any): void;
/**
*
*/
close(): void;
/**
*
* @param data response.data
*/
openVisiblity(data: any): Promise<void>;
}
/**
* @类型
* @描述
*/
class Event {
protected _events: any;
protected _firingCount: any;
/**
* ()
* @param type
* @param fn
* @param context
* ```
* :
* const fun = function(info) {
* console.log('监听事件');
* console.log(info);
* }
* event.on('add', fun); //监听添加事件
* ```
*/
on(type: string, fn: Function, context?: any): this;
/**
*
* @param type
* @param fn
* @param context
*/
private _on;
/**
* ()
* @param type
* @param fn
* @param context
* @return
* ```
* :
* event.off('add',fun);
* ```
*/
off(type: string, fn: Function, context?: any): void;
/**
*
* @param type
* @param fn
* @param context
*/
private _off;
/**
* ,,()
* @method fire
* @param type
* @param data on
* @return
* ```
* :
* const info = {} //监听时on收到的数据
* event.fire('add',info);
* ```
*/
fire(type: string, data: any): this;
/**
* ()
* @param type
* @returns
* ```
*
* const hasListens = event.listens('add');
* ```
*/
listens(type: string): boolean;
}
class Item {
protected _name: string;
protected _id: any;
/**
*
* ```
*
* item.name = 'itemName'
* ```
*/
name: string;
/**
* id不允许用修改全局唯一初始化传入或自动生成
* ```
* :
* let id = item.id;
* ```
*/
readonly id: any;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(json: object): void;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
initItem(options: any): any;
/**
* @注意 item的基类方法,
* @描述 remove方法添加时被调用
*/
destroyItem(): void;
}
class Layer extends Event {
protected _itemList: Array<Item>;
constructor();
/**
*
* @param item
*/
add(item: Item): Item;
/**
*
* @param
*/
remove(itemid: string): Item;
/**
* id获得对象
* @param itemid id
*/
getItemById(itemid: string): Item;
/**
* name获得对象
* @param itemName
*/
getItemByName(itemName: string): Item;
toJson(): any[];
/**
* json
* @param json
*/
parseJson(json: any): void;
getItemList(): Item[];
}
class Register {
_registerList: Map<ItemBaseTypeE, Map<string, any>>;
constructor();
/**
* Item
* @param type
* @param itemConstructor
*/
REGISTER(type: ItemBaseTypeE, itemConstructor: any): void;
/**
*
* @param type
* @param itemType item类型
*/
GET_CONSTRUCTOR(type: ItemBaseTypeE, itemType: string): any;
GET_REGISTER_LIST(): Map<ItemBaseTypeE, Map<string, any>>;
}
enum ItemBaseTypeE {
/**
*
*/
ImageItem = "ImageItem",
/**
*
*/
vectorItem = "vectorItem",
/**
*
*/
modelItem = "modelItem",
/**
*
*/
GraphicItem = "GraphicItem",
/**
*
*/
EfficentItem = "EfficentItem",
/**
*
*/
TileItem = "TileItem",
/**
*
*/
ActionItem = "ActionItem"
}
const gRegister: Register;
class ArrayHelper {
static Remove<T>(array: T[], t: T): void;
static moveItem<T>(array: T[], index1: any, index2: any): T[];
}
class DeComItemBase {
name: string;
comType: DeComType;
data: any;
param: any;
customElement: any;
instance: any;
option: any;
editable: boolean;
private _visible;
visible: boolean;
close(): void;
hide(): void;
onclosed: Subject<any>;
onloaded: Subject<any>;
}
class DeCustomItem extends DeComItemBase {
/**
* @param {string} customElementName
*/
constructor(element: any, option?: DeWindowOption, editable?: boolean);
}
enum DeComType {
angular = 0,
customWindowElement = 1,
customElement = 2
}
class DeWindowOption {
isFullScreen?: boolean;
width?: string;
height?: string;
left?: string;
top?: string;
right?: string;
bottom?: string;
headerVisible?: boolean;
title?: string;
zIndex?: number;
iconClass?: string;
}
abstract class DePluginBase {
/**
*
* @param {string} name
* @returns Promise
*/
search?(name: string): Promise<any[]>;
/**
*
* @param {} viewer
*/
abstract init(viewer: any): any;
/**
*
* @param {} data?
*/
abstract show(data?: any): any;
/**
* ,
*/
abstract hide(): any;
/**
*
*/
abstract close(): any;
/**
*
*/
abstract dispose(): any;
/**
* ,
*/
abstract getDisplayCondition(): any;
/**
*
* @param {any} param
* @param {boolean} onlyName 使
*/
abstract setDisplayCondition(param: any, onlyName: boolean): any;
onViewerMouseInput(mousevent: any, eventtype: any): void;
}
/**
*
*/
class DePluginAttribute {
constructor(name: string, pluginConstructor: Function, icon?: string, isSearch?: boolean, iconFont?: any, position?: any);
/**
*
*/
name: string;
/**
*
*/
icon: string;
/**
*
*/
iconFont: string;
pluginConstructor: any;
instance?: DePluginBase;
state?: PluginState;
isSearch: boolean;
position: string;
geovisEntry?: string;
}
enum PluginState {
show = 0,
hide = 1,
close = 2
}
/**
*
* {@link Tool} {@link Widget}
*/
class DePluginManager extends Event {
_viewer: any;
Tools: DePluginAttribute[];
Widgets: DePluginAttribute[];
CurrentTool: DePluginAttribute;
leftTools: DePluginAttribute[];
rightWidgets: DePluginAttribute[];
bottomTools: DePluginAttribute[];
bottomWidgets: DePluginAttribute[];
constructor(viewer: any);
registerTool(plugin: DePluginAttribute): void;
registerWidget(plugin: DePluginAttribute): void;
showTool(tool: DePluginAttribute): void;
changeTool(tool: DePluginAttribute): void;
closeTool(tool: DePluginAttribute | DePluginBase): void;
hideTool(tool: DePluginAttribute | DePluginBase): void;
createInstance(attribute: DePluginAttribute): void;
showWidget(widget: DePluginAttribute): void;
closeWidget(widget: DePluginAttribute | DePluginBase): boolean;
closeToolWidget(plugin: DePluginAttribute | DePluginBase): void;
private getPluginAttribute;
}
class DePluginViewManager {
static instance: DePluginViewManager;
comArray: DeComItemBase[];
constructor(viewer: any, toolContainer: any, onCanvasChange: any);
private _originCanvas;
private _viewer;
private _toolContainer;
private _onCanvasChange;
resetMouseBaseElement(): void;
setMouseBaseElement(element: any): void;
private customElementShow;
microAppShow(url: any, option: DeWindowOption, param: any, editable?: boolean): DeCustomItem;
iframeElementShow(url: any, option: DeWindowOption, editable?: boolean, id?: string): DeComItemBase;
iframeWindowElementShow(url: any, option: DeWindowOption, editable?: boolean, id?: string): DeComItemBase;
createIframeWindow(url: string, option: DeWindowOption, id?: string): {
element: HTMLDivElement;
iframe: HTMLIFrameElement;
closeElement: HTMLElement;
};
createIframe(url: string, name?: string): HTMLIFrameElement;
close(item: DeComItemBase): void;
}
class SinlgleDePlugin extends DePluginBase {
private viewer;
private view;
constructor(entry: string);
init(viewer: any): void;
show(data?: any): void;
hide(): void;
close(): void;
dispose(): void;
getDisplayCondition(): void;
setDisplayCondition(param: any, onlyName: boolean): void;
geovisEntry: string;
}
/**
*
*/
class BuildingMesh {
private appearance;
/**基准高度 */
private standardHeight;
private viewer;
/**水平高度 */
private minHeight;
private color;
/**
*
* @param viewer
* @param data
* @param standardHeight
* @param color
*/
constructor(viewer: Cesium.Viewer, data: Array<Array<Cesium.Cartesian3>>, standardHeight?: number, color?: string);
/**
*
* @param polygonList
*/
private createGeometry;
private createAppearance;
private getMS;
private getVs;
private getFs;
}
class CustomTilesetShader {
private vertex;
private fragment;
constructor(tileset: any, options?: any);
static SCAN: {
fragmentShader: string;
vertexShader: string;
};
static cached: Map<any, any>;
}
/**
*
*/
class CylinderGeometry {
topRadius: number;
bottomRadius: number;
position: GeoPoint;
height: number;
slice: number;
constructor(options: any);
createGeometry(): Cesium.Geometry;
getModelMatrix(): Cesium.Matrix4;
private createVertex;
/**
* attribute
* @param topPosArr
* @param bottomPosArr
*/
private createGeometeryAttribute;
/**
*
* @param postionsTemp
* @param stsTemp
*/
private createGrometry;
}
/**
*
*/
class DefenseEllipsoid {
private color;
private radius;
private position;
private viewer;
private appearance;
private primitive;
private time;
constructor(viewer: Cesium.Viewer, position: GeoPoint, radius?: number, color?: string);
/**
* primitive
*/
private createPrimitive;
private ellipsoidMs;
private getVs;
private getFs;
}
/**
*
*/
class DiffusionCircles {
private geometry;
private appearance;
private primitive;
private _viewer;
private _position;
private _radius;
private _height;
private _color;
private _inner;
/**
*
* @param viewer
* @param position
* @param radius
* @param height
* @param color
* @param inner
*/
constructor(viewer: Cesium.Viewer, position?: GeoPoint, radius?: number, height?: number, color?: string, inner?: boolean);
/**
*
*/
private startAnimate;
/**
*
*/
init(): void;
/**
*
*/
private createGeometry;
/**
*
*/
private createAppearance;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
private getInnerSource;
/**
*
*/
private getOuterSource;
/**
*
*/
clear(): void;
}
class FlowLine {
private viewer;
lineAppearance: Cesium.PolylineMaterialAppearance;
constructor(viewer: Cesium.Viewer, options: FlowLineOpt);
private create;
private createLineAppearance;
private getFlowLineSource;
private createInstance;
/**
* 线
*/
private generateCurve;
}
class FlowLineOpt {
startPoint: any;
endPoints: Array<any>;
}
/**
*
*/
class FlowTube {
private viewer;
private appearance;
private options;
constructor(viewer: Cesium.Viewer, options: FlowTubeOpt);
private createPrimitive;
private createGeometry;
/**
*
*/
private createAppearance;
private getSource;
}
/**
*
*/
class FlowTubeOpt {
/**路径 */
path: Array<GeoPoint>;
/**管道分段数 */
tubularSegments: number;
/**管道半径 */
radius: number;
/** 管道横截面分段数目*/
radialSegments: number;
}
/**
*
*/
class FogPlane {
private viewer;
private posArr;
private clampToGroud;
private primitive;
/**
*
* @param viewer
* @param posArr
* @param clampToGroud
*/
constructor(viewer: GeoCanvas, posArr: Array<GeoPoint>, clampToGroud?: boolean);
private createPrimitive;
private createApperance;
private getMs;
/**
*
*/
clear(): void;
}
/**
*
*/
class MarkPoint {
private _radius;
private _height;
private viewer;
_position: GeoPoint;
_color: string;
private partTwoMaterial;
private partFourMaterial;
private partTwoScale;
private partTwoMesh;
private primitiveCollection;
constructor(opt: MarkPointOpt);
/**
*
*/
private listenerFun;
/**
*
*/
private createPartOne;
private createPartOneImage;
private getPartOneMs;
/**
*
*/
private createPartTwo;
private createPartTwoImage;
private getPartTwoMs;
/**
*
*/
private createPartThree;
private getPartThreeMs;
private createPartFour;
private getPartFourMs;
/**
*
*/
clear(): void;
}
/**
*
*/
class MarkPointOpt {
/**
*
*/
viewer: Cesium.Viewer;
/**
*
*/
position: GeoPoint;
/**
*
*/
color: string;
/**
*
*/
radius: number;
/**
*
*/
height: number;
}
/**
* A 3D model based on glTF, the runtime asset format for WebGL, OpenGL ES, and OpenGL.
* <p>
* Cesium includes support for geometry and materials, glTF animations, and glTF skinning.
* In addition, individual glTF nodes are pickable with {@link Scene#pick} and animatable
* with {@link Model#getNode}. glTF cameras and lights are not currently supported.
* </p>
* <p>
* An external glTF asset is created with {@link (Model as any).fromGltf}. glTF JSON can also be
* created at runtime and passed to this constructor function. In either case, the
* {@link Model#readyPromise} is resolved when the model is ready to render, i.e.,
* when the external binary, image, and shader files are downloaded and the WebGL
* resources are created.
* </p>
* <p>
* Cesium supports glTF assets with the following extensions:
* <ul>
* <li>
* {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_binary_glTF/README.md|KHR_binary_glTF (glTF 1.0)}
* </li><li>
* {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_materials_common/README.md|KHR_materials_common (glTF 1.0)}
* </li><li>
* {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/WEB3D_quantized_attributes/README.md|WEB3D_quantized_attributes (glTF 1.0)}
* </li><li>
* {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_articulations/README.md|AGI_articulations}
* </li><li>
* {@link https://github.com/KhronosGroup/glTF/pull/1302|KHR_blend (draft)}
* </li><li>
* {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md|KHR_draco_mesh_compression}
* </li><li>
* {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness/README.md|KHR_materials_pbrSpecularGlossiness}
* </li><li>
* {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit/README.md|KHR_materials_unlit}
* </li><li>
* {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_techniques_webgl/README.md|KHR_techniques_webgl}
* </li><li>
* {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_transform/README.md|KHR_texture_transform}
* </li>
* </ul>
* </p>
* <p>
* For high-precision rendering, Cesium supports the {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/CESIUM_RTC/README.md|CESIUM_RTC} extension, which introduces the
* CESIUM_RTC_MODELVIEW parameter semantic that says the node is in WGS84 coordinates translated
* relative to a local origin.
* </p>
*
* @alias Model
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Object|ArrayBuffer|Uint8Array} [options.gltf] A glTF JSON object, or a binary glTF buffer.
* @param {Resource|String} [options.basePath=''] The base path that paths in the glTF JSON are relative to.
* @param {Boolean} [options.show=true] Determines if the model primitive will be shown.
* @param {Matrix4} [options.modelMatrix=Matrix4.IDENTITY] The 4x4 transformation matrix that transforms the model from model to world coordinates.
* @param {Number} [options.scale=1.0] A uniform scale applied to this model.
* @param {Number} [options.minimumPixelSize=0.0] The approximate minimum pixel size of the model regardless of zoom.
* @param {Number} [options.maximumScale] The maximum scale size of a model. An upper limit for minimumPixelSize.
* @param {Object} [options.id] A user-defined object to return when the model is picked with {@link Scene#pick}.
* @param {Boolean} [options.allowPicking=true] When <code>true</code>, each glTF mesh and primitive is pickable with {@link Scene#pick}.
* @param {Boolean} [options.incrementallyLoadTextures=true] Determine if textures may continue to stream in after the model is loaded.
* @param {Boolean} [options.asynchronous=true] Determines if model WebGL resource creation will be spread out over several frames or block until completion once all glTF files are loaded.
* @param {Boolean} [options.clampAnimations=true] Determines if the model's animations should hold a pose over frames where no keyframes are specified.
* @param {ShadowMode} [options.shadows=ShadowMode.ENABLED] Determines whether the model casts or receives shadows from light sources.
* @param {Boolean} [options.debugShowBoundingVolume=false] For debugging only. Draws the bounding sphere for each draw command in the model.
* @param {Boolean} [options.debugWireframe=false] For debugging only. Draws the model in wireframe.
* @param {HeightReference} [options.heightReference=HeightReference.NONE] Determines how the model is drawn relative to terrain.
* @param {Scene} [options.scene] Must be passed in for models that use the height reference property.
* @param {DistanceDisplayCondition} [options.distanceDisplayCondition] The condition specifying at what distance from the camera that this model will be displayed.
* @param {Color} [options.color=Color.WHITE] A color that blends with the model's rendered color.
* @param {ColorBlendMode} [options.colorBlendMode=ColorBlendMode.HIGHLIGHT] Defines how the color blends with the model.
* @param {Number} [options.colorBlendAmount=0.5] Value used to determine the color strength when the <code>colorBlendMode</code> is <code>MIX</code>. A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with any value in-between resulting in a mix of the two.
* @param {Color} [options.silhouetteColor=Color.RED] The silhouette color. If more than 256 models have silhouettes enabled, there is a small chance that overlapping models will have minor artifacts.
* @param {Number} [options.silhouetteSize=0.0] The size of the silhouette in pixels.
* @param {ClippingPlaneCollection} [options.clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
* @param {Boolean} [options.dequantizeInShader=true] Determines if a {@link https://github.com/google/draco|Draco} encoded model is dequantized on the GPU. This decreases total memory usage for encoded models.
* @param {Cartesian2} [options.imageBasedLightingFactor=Cartesian2(1.0, 1.0)] Scales diffuse and specular image-based lighting from the earth, sky, atmosphere and star skybox.
* @param {Cartesian3} [options.lightColor] The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
* @param {Number} [options.luminanceAtZenith=0.2] The sun's luminance at the zenith in kilo candela per meter squared to use for this model's procedural environment map.
* @param {Cartesian3[]} [options.sphericalHarmonicCoefficients] The third order spherical harmonic coefficients used for the diffuse color of image-based lighting.
* @param {String} [options.specularEnvironmentMaps] A URL to a KTX file that contains a cube map of the specular lighting and the convoluted specular mipmaps.
* @param {Credit|String} [options.credit] A credit for the data source, which is displayed on the canvas.
* @param {Boolean} [options.backFaceCulling=true] Whether to cull back-facing geometry. When true, back face culling is determined by the material's doubleSided property; when false, back face culling is disabled. Back faces are not culled if {@link Model#color} is translucent or {@link Model#silhouetteSize} is greater than 0.0.
*
* @see (Model as any).fromGltf
*
* @demo {@link https://sandcastle.cesium.com/index.html?src=3D%20Models.html|Cesium Sandcastle Models Demo}
*/
function Model(options: any): void;
/**
* OD线
*/
class ODLine {
viewer: Cesium.Viewer;
lineAppearance: Cesium.PolylineMaterialAppearance;
width: number;
/**
*
* @param viewer
* @param data 线
* @param width 线
*/
constructor(viewer: Cesium.Viewer, data: Array<Array<Cesium.Cartesian3>>, width?: number);
private createLineGeometry;
private createLineAppearance;
private getPolylineMs;
}
/**
*
*/
class ParticleCylinderGeometry {
topRadius: number;
bottomRadius: number;
position: GeoPoint;
height: number;
slice: number;
constructor(options: any);
createGeometry(): Cesium.Geometry;
getModelMatrix(): Cesium.Matrix4;
private createVertex;
/**
* attribute
* @param topPosArr
* @param bottomPosArr
*/
private createGeometeryAttribute;
/**
*
* @param postionsTemp
* @param stsTemp
*/
private createGrometry;
}
/**
* 2
* +
*/
interface ParticleOrbitingConeCircle {
radius: number;
height: number;
}
interface ParticleOrbitingConeParticle {
topRadius: number;
bottomRadius: number;
height: number;
}
class ParticleOrbitingCone {
position: GeoPoint;
color: string;
circles: Array<ParticleOrbitingConeCircle>;
particleOpt: ParticleOrbitingConeParticle;
private viewer;
private particleAppearance;
constructor(viewer: Cesium.Viewer, options: ParticleOrbitingConeOpt);
/**创建底部圆环 */
private addCircles;
private createCirclesImage;
/**创建椎体 */
private createCone;
/**绘制椎体图片 */
private createConeImage;
/**
*
*/
private addParticleEffect;
/**粒子特效着色器片段 */
private getParticleSource;
}
class ParticleOrbitingConeOpt {
position: GeoPoint;
color: string;
circles: Array<ParticleOrbitingConeCircle>;
particle: ParticleOrbitingConeParticle;
}
/**
*
*/
class Pentahedron {
private appearance;
private primitive;
private _viewer;
private _position;
private _topRadius;
private _bottomRadius;
private _height;
private _color;
private _slice;
private _speed;
private _angle;
/**
*
* @param _viewer
* @param position
* @param topRadius
* @param bottomRadius
* @param height
* @param color
* @param slice
* @param speed
*/
constructor(_viewer: Cesium.Viewer, position?: GeoPoint, topRadius?: number, bottomRadius?: number, height?: number, color?: string, slice?: number, speed?: number);
/**
*
*/
listenerFun: () => void;
/**
*
*/
private init;
/**
*
*/
private createAppearance;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
private createGeometry;
/**
* modelMatrix
*/
private createMatrix;
/**着色器代码段 */
private getSource;
/**
*
*/
clear(): void;
/**
*
* @returns
*/
/**
*
* @param value
*/
color: string;
/**
*
* @returns
*/
/**
*
* @param value
*/
position: GeoPoint;
}
class RotatingPentahedron {
private options;
private boxLength;
private angle;
private viewer;
private appearance;
private primitive;
constructor(viewer: Cesium.Viewer, options: RotatingPentahedronOpt);
/**
*
*/
private createPrimitive;
private createGeometry;
/**
* &
*/
private createAttributes;
private createMatrix;
private createAppearance;
private listenerFunc;
}
class RotatingPentahedronOpt {
position: GeoPoint;
color: string;
}
/**
*
*/
class SpreadCylinder {
private dataItem;
private appearance;
private viewer;
private updateAttribute;
private primitive;
constructor(viewer: Cesium.Viewer, dataItem: SpreadCylinderOpt);
/**
*
*/
private createPrimitive;
/**
*
*/
private createImage;
/**
*
*/
private getCylinderMS;
private listenerFun;
}
/**
*
*/
class SpreadCylinderOpt {
/**顶面半径 */
topRadius: number;
/**底面半径 */
bottomRadius: number;
/**圆柱位置 以底面圆心为中心 */
position: GeoPoint;
/**圆柱高度 */
height: number;
/**切分份数 */
slice: number;
/**圆柱颜色 */
color: string;
}
/**
* 线
*/
class SpreadLine {
private polygonAppearance;
private polygonGeometry;
private polygonPrimitive;
private _viewer;
private _color;
private _position;
private _radius;
/**
*
* @param viewer
* @param radius
* @param color
* @param position
*/
constructor(viewer: Cesium.Viewer, position?: GeoPoint, radius?: number, color?: string);
/**
*
*/
private listenerFun;
/**
*
*/
private init;
/**
*
*/
private createGeometry;
/**
*
*/
private createAppearence;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
private getSource;
/**
*
*/
clear(): void;
/**
*
* @returns
*/
/**
*
* @param value
*/
color: string;
/**
*
* @returns
*/
/**
*
* @param value
*/
position: GeoPoint;
/**
*
* @returns
*/
/**
*
* @param value
*/
radius: number;
}
/**
* (Truncated cone) +
*/
class TruncatedCone {
private viewer;
private options;
private partTowAppearance;
constructor(viewer: Cesium.Viewer, options: TruncatedConeOpt);
private createPartOne;
private createPartOneImage;
private createPartTwo;
private createPartTwoImage;
private createPartThree;
private createPartThreeImage;
private getPartThreeSource;
}
/**
*
*/
class TruncatedConeOpt {
/**底部圆环中心坐标 */
circleCenter: GeoPoint;
/**主体颜色 */
color: string;
/**底部双圆环半径 */
circleRadius: number;
/**底部虚线圆半径 */
dottedCircleRadius: number;
/**外截圆锥体顶部半径 */
outerTopRadius: number;
/**外截圆锥体底部半径 */
outerBottomRadius: number;
/**外截圆锥体高度 */
outerHeight: number;
/**内截圆锥体顶部半径 */
innerTopRadius: number;
/**内截圆锥体底部半径 */
innerBottomRadius: number;
/**内截圆锥体高度 */
innerHeight: number;
}
class BaseCreator extends Event {
protected _viewer: Cesium.Viewer;
protected _father: CreatorManager;
private _handler;
private _controlPointSet;
constructor(viewer: Cesium.Viewer, father: CreatorManager);
/** handler单例 */
protected getHandler(): Cesium.ScreenSpaceEventHandler;
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
protected setCtrPoint(point: GeoPoint, text?: string): void;
protected addCtrPoint(point: GeoPoint, text?: string): void;
protected clearCtrPint(): void;
protected createFinish(item: GraphicItem): void;
protected createItem(item: GraphicItem): void;
clear(): void;
}
class CircularCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
}
class CreatorManager extends Event {
private _viewer;
private _creatorList;
private _currentCreator;
private _controlPointSet;
private _graphicLayer;
constructor(viewer: Cesium.Viewer, graphicLayer: GraphicLayer);
/**
*
*/
readonly controlPointSet: ControlPointSet;
/**
*
*/
private _getCreatorByType;
setCursor(cursor: any): void;
/**
*
* @param itemOpt
* @param group
* @param finishCallback
*/
create(itemOpt: any, group: GraphicGroup, finishCallback: any): GraphicItem;
/**
*
*/
stopCreate(): void;
}
class CylinderDynamicCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): CylinderDynamicGraphic;
}
class EllipseCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
}
class LabelBillboardCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
}
class LabelRectCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
}
class PointCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
}
class PolylineCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
}
class RectangleCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
}
class RectangleLineCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
private getCoordinates;
}
class ScreenTextCreator extends BaseCreator {
constructor(viewer: Cesium.Viewer, father: CreatorManager);
create(itemOpt: any, group: GraphicGroup, finishCallback?: any): GraphicItem;
}
/**
*@ignore
*/
class BaseEditor extends Event {
protected _viewer: Cesium.Viewer;
protected _father: EditorManager;
protected _editItem: GraphicItem;
private _handler;
protected _controlPointSet: ControlPointSet;
protected _screenEditor: ScreenEditor;
constructor(viewer: Cesium.Viewer, father: EditorManager);
setEditorOwnerElement(element: Element): void;
/** handler单例 */
protected getHandler(): Cesium.ScreenSpaceEventHandler;
/**
*
* @param item
*/
setEditItem(item: GraphicItem): void;
protected clearCtrPint(): void;
protected addCtrPoint(position: GeoPoint): void;
protected createItem(item: GraphicItem): void;
protected setCtrlActive(item: GraphicItem, val: boolean): void;
clear(): void;
getPositions(): Array<GeoPoint>;
/**
* id
* @param x
* @param y
*/
getActiveIndex(x: any, y: any): any;
private _screenPixel;
protected _getLengthByMouse(diff: any, heightCoeficient?: number): number;
/**
*
*/
cancelActive(index: any): void;
/**
*
* @param item
*/
isClamp(item: GraphicItem): boolean;
updateCtrlPts(editItem: GraphicItem): void;
}
/**
*@ignore
*/
class CircularEditor extends BaseEditor {
private _geoPoints;
/**
*
* @param center
* @param r
*/
private getRadiusCtrlPoint;
private build;
setEditItem(item: GraphicItem): void;
updateCtrlPts(editItem: GraphicItem): void;
getPositions(): GeoPoint[];
}
/**
*@ignore
*/
class CylinderDynamicEditor extends BaseEditor {
setEditItem(item: CylinderDynamicGraphic): void;
getPositions(): any[];
}
/**
*@ignore
*/
class EditorManager extends Event {
private _isCreating;
private _isEditting;
private _viewer;
private _editItem;
private _controlPointSet;
private _currentEditor;
private _itemChangeListenerFun;
private _editorClickListenerFun;
private _editorMouseLeftUpFun;
private _editorOwnerElement;
private _wholeEditor;
private _handler;
_graphicLayer: GraphicLayer;
constructor(viewer: Cesium.Viewer, graphicLayer: GraphicLayer);
/**
*
*/
isCreating: boolean;
readonly isEditting: boolean;
/**
*
*/
getHandler(): Cesium.ScreenSpaceEventHandler;
/**
*
*/
open(): void;
/**
*
*/
close(): void;
/**
*
*/
readonly controlPointSet: ControlPointSet;
private getEditorByType;
setCursor(cursor: any): void;
/**
*
*/
setEditItem(item: GraphicItem): void;
/**
* dom
*/
setEditorOwnerElement(element: Element): void;
/**
*
*/
setItemRealTimeChangeListener(fun: Function): void;
/**
*
*/
removeItemRealTimeChangeListener(): void;
/**
*
*/
setEditorClickListener(fun: any): void;
/**
*
*/
removeEditorClickListener(): void;
/**
*
*/
setEditorMouseLeftUpListener(fun: Function): void;
/**
*
*/
removeEditorMouseLeftUpListener(): void;
/**
*
*/
getEditItem(): GraphicItem;
/**
* @description:
* @param {ScreenTextGraphic} graphic
* @return {*}
*/
openScreenTextEdit(graphic: ScreenTextGraphic): void;
private _openScreenTextsEdit;
private _closeScreenTextEdit;
private _openScreenTextEdit;
}
/**
*@ignore
*/
class EllipseEditor extends BaseEditor {
private _geoPoints;
/**
*
* @param center
* @param r
* @param angle 090180270西
*/
private getRadiusCtrlPoint;
private build;
setEditItem(item: GraphicItem): void;
updateCtrlPts(editItem: GraphicItem): void;
getPositions(): GeoPoint[];
}
/**
*@ignore
*/
class FlagEditor extends BaseEditor {
constructor(viewer: Cesium.Viewer, father: EditorManager);
initScreenEditor(): void;
setEditItem(item: GraphicItem): void;
clear(): void;
}
/**
*@ignore
*/
class LabelBillboardEditor extends BaseEditor {
private startMove;
constructor(viewer: Cesium.Viewer, father: EditorManager);
initScreenEditor(): void;
setEditItem(item: GraphicItem): void;
clear(): void;
}
/**
*@ignore
*/
class LabelRectEditor extends BaseEditor {
constructor(viewer: Cesium.Viewer, father: EditorManager);
initScreenEditor(): void;
setEditItem(item: GraphicItem): void;
clear(): void;
}
/**
*@ignore
*/
class LineEditor extends BaseEditor {
protected _picker: Picking;
constructor(viewer: Cesium.Viewer, father: EditorManager);
/**
*
* @param p0
* @param editItem
*/
private getInsertIndex;
setEditItem(editItem: GraphicItem): void;
clear(): void;
getPositions(): any;
updateCtrlPts(editItem: GraphicItem): void;
}
/**
*@ignore
*/
class ObliqueEditor extends BaseEditor {
constructor(viewer: Cesium.Viewer, father: EditorManager);
initScreenEditor(): void;
setEditItem(item: any): void;
clear(): void;
}
/**
*@ignore
*/
class PointEditor extends BaseEditor {
setEditItem(editItem: GraphicItem): void;
getPositions(): Array<GeoPoint>;
updateCtrlPts(editItem: GraphicItem): void;
}
class PolygonEditor extends LineEditor {
setEditItem(editItem: GraphicItem): void;
getPositions(): any;
private getHeightEditVisible;
updateCtrlPts(editItem: GraphicItem): void;
}
/**
*@ignore
*/
class RectangleEditor extends BaseEditor {
setEditItem(item: GraphicItem): void;
updateCtrlPts(editItem: GraphicItem): void;
getPositions(): any;
}
/**
*@ignore
*/
class ScreenEditor {
private _operatorContainer;
private _viewer;
private _operators;
private _isOpen;
private _divContainer;
getCenterCallback: any;
ctrlPtsUpdateCallback: any;
moveDivContainer: () => void;
mousemove: (event: any) => void;
mouseup: (event: any) => void;
constructor(viewer: Cesium.Viewer);
/**获取地理画布即按钮容器div的父容器 */
private getOwnerElement;
setOwnerElement(element: Element): void;
/**
*
*/
setOperators(operators: Array<Operator>): void;
/**
*
*/
centerCallback: Function;
/**
*
*/
updateCtrlPtsCallback: Function;
/**
*
*/
open(): void;
/**
*
*/
close(): void;
/**
*
*/
_clear(): void;
/**
*
*/
private _createOperators;
}
class Operator {
Image: string;
ToolTip: string;
Operator: Function;
CanOperator?: Function;
htmlElement?: HTMLElement;
}
class ScreenTextEditor extends BaseEditor {
setEditItem(editItem: GraphicItem): void;
clear(): void;
protected getHandler(): any;
protected clearCtrPint(): void;
protected addCtrPoint(): void;
protected createItem(item: GraphicItem): void;
protected controlPointList(): any[];
protected setCtrlActive(item: GraphicItem, val: boolean): void;
getPositions(): any[];
getActiveIndex(x: any, y: any): number;
protected _getLengthByMouse(diff: any, heightCoeficient?: number): number;
cancelActive(index: any): void;
isClamp(item: GraphicItem): boolean;
updateCtrlPts(editItem: GraphicItem): void;
}
/**
*@ignore
*/
class WholeEditor {
private _viewer;
private _editItem;
private _screenEditor;
constructor(viewer: Cesium.Viewer);
initScreenEditor(): void;
setEditorOwnerElement(element: Element): void;
/**通过设置所编辑的标绘对象来激活当前编辑器 */
setEditItem(item: GraphicItem): void;
/**
*
*/
updateCtrlPtsCallback: Function;
clear(): void;
/**
* heading
* @param start
* @param end
*/
rotateByHeading(start: Cesium.Cartesian2, end: Cesium.Cartesian2): void;
/**
* Pich
* @param start
* @param end
*/
rotateByPitch(start: Cesium.Cartesian2, end: Cesium.Cartesian2): void;
/**
* Roll
* @param start
* @param end
*/
rotateByRoll(start: Cesium.Cartesian2, end: Cesium.Cartesian2): void;
/**
*
* @param start
* @param end
*/
movePosition(start: any, end: any): void;
private _screenPixel;
private _getLengthByMouse;
/**
*
* @param start
* @param end
*/
moveHeight(start: any, end: any): void;
/**
*
* @param start
* @param end
*/
moveScale(start: any, end: any): void;
}
/**
*@ignore
*/
class BaseControlPoint {
protected _group: GraphicGroup;
protected _index: number;
protected _position: GeoPoint;
protected _text: string;
protected _showText: boolean;
protected _isFormat: boolean;
protected _viewer: any;
constructor(viewer: Cesium.Viewer, group: GraphicGroup, position: GeoPoint, index: number, text?: string);
/**
*
*/
init(position: GeoPoint): void;
/**
*
* @param index
*/
setIndex(index: number): void;
/**
*
* @param b
*/
setVisible(b: boolean): void;
/**
*
*/
getLabelVisible(): boolean;
/**
*
* @param b
*/
setLabelVisible(b: boolean): void;
/**
*
* @param b
*/
setLabelFormat(b: boolean): void;
/**
*
* @param position
* @param text
*/
setPosition(position: GeoPoint, text?: string): void;
getPosition(): GeoPoint;
clear(): void;
}
/**
*@ignore
*/
class ControlPoint extends BaseControlPoint {
private _graphics;
private _decimal;
private _labelText;
static highlightColor: string;
static normalColor: string;
static removeColor: string;
constructor(viewer: Cesium.Viewer, group: GraphicGroup, position: GeoPoint, index: number, text: string);
/**
*@ignore
*
*/
init(position: GeoPoint): void;
private buildPositionText;
private buildPositionText_DegreeMinutesSecond;
/**
*
* @param index
*/
setIndex(index: number): void;
/**
*
* @param b
*/
setVisible(b: boolean): void;
/**
*
* @param b
*/
setLabelVisible(b: boolean): void;
/**
*
* @param b
*/
setLabelFormat(b: boolean): void;
/**
*
* @param position
* @param text
*/
setPosition(position: GeoPoint, text?: string): void;
/**
*
* @param item
* @param val
*/
static setCtrlActive(item: GraphicItem, val: boolean): void;
/**
* billboard的显隐
* @param bool
*/
setHeightEditVisible(bool: boolean): void;
/**
* billboard的显隐
* @param bool
*/
setRemoveEditVisible(bool: boolean): void;
clear(): void;
}
/**
*@ignore
*/
class ControlPointSet {
private _viewer;
private _pointConstructor;
private _pointList;
private _validPtNum;
private _labelVisible;
private _labelFormat;
private _group;
_graphicLayer: GraphicLayer;
constructor(viewer: Cesium.Viewer, graphicLayer: GraphicLayer);
/**
*
* @param value
*/
setPointConstructor(value: BaseControlPoint): void;
/**
*
* @param point
* @param text
*/
add(point: GeoPoint, text?: string): void;
/**
*
*/
setPosition(point: GeoPoint, text?: string): void;
/**
*
*/
updatePosition(point: GeoPoint, index: number, text?: string): void;
/**
*
*/
getList(): BaseControlPoint[];
/**
*
*/
getValidPtNum(): number;
/**
*
* @param val
*/
setCtrlActive(item: any, val: any): void;
/**
* billboard的显隐
* @param b
* @param index 00
*/
setHeightEditVisible(b: boolean, index?: number): void;
/**
*
* @param b
* @param index 00
*/
setRemoveEditVisible(b: boolean, index?: number): void;
/**
*
* @param b
*/
setLabelVisible(b: boolean): void;
/**
*
* @param b
*/
setLabelFormat(b: boolean): void;
clear(): void;
updateCtrPositions(positions: Array<GeoPoint>): void;
}
let gv: {
Version: string;
Item: typeof Item;
Layer: typeof Layer;
Event: typeof Event;
GeoCanvas: typeof GeoCanvas;
Calculate: typeof Calculate;
Check: typeof Check;
GeoPoint: typeof GeoPoint;
ViewPoint: typeof ViewPoint;
Util: typeof Util;
LayerManager: typeof LayerManager;
SceneOptions: typeof SceneOptions;
WeatherEnmu: typeof WeatherEnmu;
LevelCodeEnum: typeof LevelCodeEnum;
HeightReferenceEnum: typeof HeightReferenceEnum;
PluginManager: typeof PluginManager;
GraphicLayer: typeof GraphicLayer;
SatelliteLayer: typeof SatelliteLayer;
ImageLayer: typeof ImageLayer;
TargetLayer: typeof TargetLayer;
TargetItem: typeof TargetItem;
TargetState: typeof TargetState;
TargetStyle: typeof TargetStyle;
TargetHistory: typeof TargetHistory;
TileLayer: typeof TileLayer;
SpaceDebris: typeof SpaceDebris;
SpaceDebrisOpt: typeof SpaceDebrisOpt;
Windy: typeof Windy;
Cluster: typeof Cluster;
ClusterOpt: typeof ClusterOpt;
Canvas2Image: typeof Canvas2Image;
HeatMap: typeof HeatMap;
HeatMapOpt: typeof HeatMapOpt;
MapV: typeof MapV;
MapVOpt: typeof MapVOpt;
MassiveLines: typeof MassiveLines;
MassiveLinesOpt: typeof MassiveLinesOpt;
MassivePoints: typeof MassivePoints;
PointOption: typeof PointOption;
PointStyle: typeof PointStyle;
MassivePolygons: typeof MassivePolygons;
MassivePolygonOpt: typeof MassivePolygonOpt;
PlaceNameTile: typeof PlaceNameTile;
PlaceNameTileOpt: typeof PlaceNameTileOpt;
JQPlaceNameTile: typeof JQPlaceNameTile;
PlaceFontStyle: typeof PlaceFontStyle;
PolygonTileOpt: typeof PolygonTileOpt;
PolygonTile: typeof PolygonTile;
IconTile: typeof IconTile;
IconTileOpt: typeof IconTileOpt;
ObliqueTile: typeof ObliqueTile;
TileScaleImageProvider: any;
LineTile: typeof LineTile;
LineTileOpt: typeof LineTileOpt;
VectorTileItem: typeof VectorTileItem;
VectorTileItemOpt: typeof VectorTileItemOpt;
Satellite: typeof Satellite;
SatelliteOpt: typeof SatelliteOpt;
StatelliteEnum: typeof StatelliteEnum;
SatelliteOrbitType: typeof SatelliteOrbitType;
SatelliteComponents: typeof SatelliteComponents;
PointGraphic: typeof PointGraphic;
CylinderDynamicGraphic: typeof CylinderDynamicGraphic;
CylinderDynamicGraphicOpt: typeof CylinderDynamicGraphicOpt;
SectorGraphic: typeof SectorGraphic;
SectorGraphicOpt: typeof SectorGraphicOpt;
WeatherGraphic: typeof WeatherGraphic;
WeatherGraphicOpt: typeof WeatherGraphicOpt;
WaterGraphic: typeof WaterGraphic;
WaterGraphicOpt: typeof WaterGraphicOpt;
PolylineGraphic: typeof PolylineGraphic;
PolylineGraphicOpt: typeof PolylineGraphicOpt;
ColorStyle: typeof ColorStyle;
ArrowStyle: typeof ArrowStyle;
OutlineStyle: typeof OutlineStyle;
DashStyle: typeof DashStyle;
GlowStyle: typeof GlowStyle;
DynamicStyle: typeof DynamicStyle;
TextureStyle: typeof TextureStyle;
DynamicIconEnum: typeof DynamicIconEnum;
TextureIconEnum: typeof TextureIconEnum;
PolylineStyleEnum: typeof PolylineStyleEnum;
BezierLineGraphic: typeof BezierLineGraphic;
BezierLineGraphicOpt: typeof BezierLineGraphicOpt;
ParabolaLineGraphic: typeof ParabolaLineGraphic;
ParabolaLineGraphicOpt: typeof ParabolaLineGraphicOpt;
ArcTypeEnum: typeof ArcTypeEnum;
BubbleGraphic: typeof BubbleGraphic;
BubbleGraphicOpt: typeof BubbleGraphicOpt;
BubbleTypeEnum: typeof BubbleTypeEnum;
LabelGraphic: typeof LabelGraphic;
LabelGraphicOpt: typeof LabelGraphicOpt;
ModelGraphic: typeof ModelGraphic;
ModelGraphicOpt: typeof ModelGraphicOpt;
BillboardGraphic: typeof BillboardGraphic;
BillboardGraphicOpt: typeof BillboardGraphicOpt;
ScanGraphic: typeof ScanGraphic;
ScanGraphicOpt: typeof ScanGraphicOpt;
SensorGraphic: typeof SensorGraphic;
SensorGraphicOpt: typeof SensorGraphicOpt;
SpreadGraphic: typeof SpreadGraphic;
SpreadGraphicOpt: typeof SpreadGraphicOpt;
EllipseGraphic: typeof EllipseGraphic;
EllipseGraphicOpt: typeof EllipseGraphicOpt;
RectangleGraphic: typeof RectangleGraphic;
RectangleGraphicOpt: typeof RectangleGraphicOpt;
EllipsoidGraphic: typeof EllipsoidGraphic;
EllipsoidGraphicOpt: typeof EllipsoidGraphicOpt;
SphereGraphic: typeof SphereGraphic;
SphereGraphicOpt: typeof SphereGraphicOpt;
WallGraphic: typeof WallGraphic;
WallGraphicOpt: typeof WallGraphicOpt;
PipelineManager: typeof PipelineManager;
PipelineGraphic: typeof PipelineGraphic;
PipelineStripGraphic: typeof PipelineStripGraphic;
PipelineGraphicOpt: typeof PipelineGraphicOpt;
PipelineTurnGraphic: typeof PipelineTurnGraphic;
PipelineTurnGraphicOpt: typeof PipelineTurnGraphicOpt;
PipeTurnTwoGraphic: typeof PipeTurnTwoGraphic;
PipeTurnThreeGraphic: typeof PipeTurnThreeGraphic;
VolumePolylineGraphic: typeof VolumePolylineGraphic;
VolumePolylineGraphicOpt: typeof VolumePolylineGraphicOpt;
CylinderGraphic: typeof CylinderGraphic;
CylinderGraphicOpt: typeof CylinderGraphicOpt;
RadarGraphic: typeof RadarGraphic;
RadarGraphicOpt: typeof RadarGraphicOpt;
DynamicRippleGraphicOpt: typeof DynamicRippleGraphicOpt;
DynamicRippleGraphic: typeof DynamicRippleGraphic;
GraphicGroup: typeof GraphicGroup;
PolygonGraphic: typeof PolygonGraphic;
PolygonGraphicOpt: typeof PolygonGraphicOpt;
FlagGraphic: typeof FlagGraphic;
FlagGraphicOpt: typeof FlagGraphicOpt;
PluginView: typeof PluginView;
Tool: typeof Tool;
Widget: typeof Widget;
PopoverGraphic: typeof PopoverGraphic;
PopoverGraphicOpt: typeof PopoverGraphicOpt;
JBLineGraphic: typeof JBLineGraphic;
JBLineGraphicOpt: typeof JBLineGraphicOpt;
JBPointGraphic: typeof JBPointGraphic;
JBPointGraphicOpt: typeof JBPointGraphicOpt;
JBRenderModeEnum: typeof JBRenderModeEnum;
CircularGraphic: typeof CircularGraphic;
CircularGraphicOpt: typeof CircularGraphicOpt;
Path: typeof Path;
PathManager: typeof PathManager;
TriangleMeshGraphicOpt: typeof TriangleMeshGraphicOpt;
TriangleMeshGraphic: typeof TriangleMeshGraphic;
TerrainLayerCollection: typeof TerrainLayerCollection;
TerrainItem: typeof TerrainItem;
iCenter: typeof iCenter;
Analysis: typeof Analysis;
Camera: typeof Camera;
MeasureAreaOpt: typeof MeasureAreaOpt;
MeasureDistanceOpt: typeof MeasureDistanceOpt;
FloodAnalysisOpt: typeof FloodAnalysisOpt;
CustomLabelGraphic: typeof CustomLabelGraphic;
CustomLabelGraphicOpt: typeof CustomLabelGraphicOpt;
IntervisibilityAnalysis: typeof IntervisibilityAnalysis;
HideAnalysis: typeof HideAnalysis;
PathAnalysis: typeof PathAnalysis;
PolygonVisiableAnalysis: typeof PolygonVisiableAnalysis;
SlopeAnalysis: typeof SlopeAnalysis;
SkylineAnalyze: typeof SkylineAnalyze;
SkylineOption: typeof SkylineOption;
PlaceNameService: typeof PlaceNameService;
BufferAnalysis: typeof BufferAnalysis;
LabelBillboardGraphic: typeof LabelBillboardGraphic;
LabelBillboardGraphicOpt: typeof LabelBillboardGraphicOpt;
LabelRectGraphic: typeof LabelRectGraphic;
LabelRectGraphicOpt: typeof LabelRectGraphicOpt;
BackLineMode: typeof BackLineMode;
DePluginManager: typeof DePluginManager;
DePluginViewManager: typeof DePluginViewManager;
BilTerrainProvider: any;
TMSTerrainProvider: typeof TMSTerrainProvider;
BaiduImageryProvider: typeof BaiduImageryProvider;
GVDocument: typeof GVDocument;
DashBoardGraphic: typeof DashBoardGraphic;
DashGraphicOpt: typeof DashGraphicOpt;
BindedCylinderGraphic: typeof BindedCylinderGraphic;
BindedCylinderOpt: typeof BindedCylinderOpt;
GradientSectorGraphic: typeof GradientSectorGraphic;
GradientSectorGraphicOpt: typeof GradientSectorGraphicOpt;
CompoundImage: typeof CompoundImage;
HDVImageOption: typeof HDVImageOption;
MapSheet: typeof MapSheet;
MapBox: typeof MapBox;
MapBoxOpt: typeof MapBoxOpt;
StaticMapBox: typeof StaticMapBox;
StaticMapBoxOpt: typeof StaticMapBoxOpt;
PathPlanning: typeof PathPlanning;
PathPlanningOpt: typeof PathPlanningOpt;
ObliqueGraphic: typeof ObliqueGraphic;
ObliqueGraphicOpt: typeof ObliqueGraphicOpt;
GeoVector3: typeof GeoVector3;
ViewShedPrimitive: typeof ViewShedPrimitive;
PbfImageryProvider: any;
createMapBoxStyle: any;
ArcGisImagery: typeof ArcGisImagery;
ArcGisImageryOpt: typeof ArcGisImageryOpt;
BingImagery: typeof BingImagery;
BingImageryOpt: typeof BingImageryOpt;
OSMImagery: typeof OSMImagery;
OSMImageryOpt: typeof OSMImageryOpt;
UrlTemplateImagery: typeof UrlTemplateImagery;
UrlTemplateImageryOpt: typeof UrlTemplateImageryOpt;
WMSImagery: typeof WMSImagery;
WMSImageryOpt: typeof WMSImageryOpt;
WMTSImagery: typeof WMTSImagery;
WMTSImageryOpt: typeof WMTSImageryOpt;
KMLLayer: typeof KMLLayer;
KMLLayerOpt: typeof KMLLayerOpt;
GeoJsonLayer: typeof GeoJsonLayer;
GeoJsonLayerOpt: typeof GeoJsonLayerOpt;
Cesium3DTileLayer: typeof Cesium3DTileLayer;
Cesium3DTileLayerOpt: typeof Cesium3DTileLayerOpt;
BuildingMesh: typeof BuildingMesh;
ODLine: typeof ODLine;
SpreadCylinder: typeof SpreadCylinder;
SpreadCylinderOpt: typeof SpreadCylinderOpt;
DefenseEllipsoid: typeof DefenseEllipsoid;
CustomTilesetShader: typeof CustomTilesetShader;
SpecularReflection: typeof SpecularReflection;
RotatingPentahedron: typeof RotatingPentahedron;
FlowLine: typeof FlowLine;
CylinderGeometry: typeof CylinderGeometry;
FlowTube: typeof FlowTube;
FlowTubeOpt: typeof FlowTubeOpt;
DiffusionCircles: typeof DiffusionCircles;
Pentahedron: typeof Pentahedron;
TruncatedCone: typeof TruncatedCone;
ParticleOrbitingCone: typeof ParticleOrbitingCone;
EarthTheme: typeof EarthTheme;
SkyboxTheme: typeof SkyboxTheme;
ActionLayer: typeof ActionLayer;
PathAction: typeof PathAction;
CameraAction: typeof CameraAction;
VisibleAction: typeof VisibleAction;
FlickerAction: typeof FlickerAction;
FadeOutAction: typeof FadeOutAction;
ScaleAction: typeof ScaleAction;
IconGraphicOpt: typeof IconGraphicOpt;
CircleIconGraphic: typeof CircleIconGraphic;
WaveIconGraphic: typeof WaveIconGraphic;
WarnIconGraphic: typeof WarnIconGraphic;
WaterFaceGraphicOpt: typeof WaterFaceGraphicOpt;
WaterFaceGraphic: typeof WaterFaceGraphic;
AttractPointGraphic: typeof AttractPointGraphic;
AttractPointGraphicOpt: typeof AttractPointGraphicOpt;
TruncatedConeGraphic: typeof TruncatedConeGraphic;
TruncatedConeGraphicOpt: typeof TruncatedConeGraphicOpt;
TruncatedConeParticleGraphic: typeof TruncatedConeParticleGraphic;
TruncatedConeParticleGraphicOpt: typeof TruncatedConeParticleGraphicOpt;
SpreadCircleGraphic: typeof SpreadCircleGraphic;
SpreadCircleGraphicOpt: typeof SpreadCircleGraphicOpt;
SpreadCircleLineGraphic: typeof SpreadCircleLineGraphic;
SpreadCircleLineGraphicOpt: typeof SpreadCircleLineGraphicOpt;
SpreadCircleLineEnum: typeof SpreadCircleLineEnum;
SpreadCircleClampGraphic: typeof SpreadCircleClampGraphic;
SpreadCircleRampGraphic: typeof SpreadCircleRampGraphic;
SpreadCircleRampGraphicOpt: typeof SpreadCircleRampGraphicOpt;
SpreadCircleRingGraphic: typeof SpreadCircleRingGraphic;
SpreadCircleRingGraphicOpt: typeof SpreadCircleRingGraphicOpt;
SpreadCircleRingEnum: typeof SpreadCircleRingEnum;
FlowWallGraphic: typeof FlowWallGraphic;
FlowWallGraphicOpt: typeof FlowWallGraphicOpt;
DirEnum: typeof DirEnum;
GeoSotLayer: typeof GeoSotLayer;
GroundClippingAnalysis: typeof GroundClippingAnalysis;
NuclearProtectionAnalysis: typeof NuclearProtectionAnalysis;
MorphologicAnalysis: typeof MorphologicAnalysis;
MorphologicModelEnum: typeof MorphologicModelEnum;
SelectionTool: typeof SelectionTool;
BlastGraphic: typeof BlastGraphic;
BlastGraphicOpt: typeof BlastGraphicOpt;
FireGraphic: typeof FireGraphic;
FireGraphicOpt: typeof FireGraphicOpt;
FireGraphicEnum: typeof FireGraphicEnum;
ColorTable: typeof ColorTable;
CloundLayer: typeof CloundLayer;
ScreenTextGraphic: typeof ScreenTextGraphic;
ScreenTextGraphicOpt: typeof ScreenTextGraphicOpt;
FirstPersonControl: typeof FirstPersonControl;
FogPlane: typeof FogPlane;
BDTileLayer: typeof BDTileLayer;
};
let gv: {
Version: string;
Item: typeof Item;
Layer: typeof Layer;
Event: typeof Event;
GeoCanvas: typeof GeoCanvas;
Calculate: typeof Calculate;
Check: typeof Check;
GeoPoint: typeof GeoPoint;
ViewPoint: typeof ViewPoint;
Util: typeof Util;
LayerManager: typeof LayerManager;
SceneOptions: typeof SceneOptions;
WeatherEnmu: typeof WeatherEnmu;
LevelCodeEnum: typeof LevelCodeEnum;
HeightReferenceEnum: typeof HeightReferenceEnum;
PluginManager: typeof PluginManager;
GraphicLayer: typeof GraphicLayer;
ImageLayer: typeof ImageLayer;
TileLayer: typeof TileLayer;
SpaceDebris: typeof SpaceDebris;
SpaceDebrisOpt: typeof SpaceDebrisOpt;
Windy: typeof Windy;
Cluster: typeof Cluster;
ClusterOpt: typeof ClusterOpt;
Canvas2Image: typeof Canvas2Image;
HeatMap: typeof HeatMap;
HeatMapOpt: typeof HeatMapOpt;
MapV: typeof MapV;
MapVOpt: typeof MapVOpt;
MassiveLines: typeof MassiveLines;
MassiveLinesOpt: typeof MassiveLinesOpt;
MassivePoints: typeof MassivePoints;
PointOption: typeof PointOption;
PointStyle: typeof PointStyle;
MassivePolygons: typeof MassivePolygons;
MassivePolygonOpt: typeof MassivePolygonOpt;
PlaceNameTile: typeof PlaceNameTile;
PlaceNameTileOpt: typeof PlaceNameTileOpt;
JQPlaceNameTile: typeof JQPlaceNameTile;
PlaceFontStyle: typeof PlaceFontStyle;
PolygonTileOpt: typeof PolygonTileOpt;
PolygonTile: typeof PolygonTile;
IconTile: typeof IconTile;
IconTileOpt: typeof IconTileOpt;
ObliqueTile: typeof ObliqueTile;
TileScaleImageProvider: any;
LineTile: typeof LineTile;
LineTileOpt: typeof LineTileOpt;
VectorTileItem: typeof VectorTileItem;
VectorTileItemOpt: typeof VectorTileItemOpt;
PointGraphic: typeof PointGraphic;
CylinderDynamicGraphic: typeof CylinderDynamicGraphic;
CylinderDynamicGraphicOpt: typeof CylinderDynamicGraphicOpt;
SectorGraphic: typeof SectorGraphic;
SectorGraphicOpt: typeof SectorGraphicOpt;
WeatherGraphic: typeof WeatherGraphic;
WeatherGraphicOpt: typeof WeatherGraphicOpt;
WaterGraphic: typeof WaterGraphic;
WaterGraphicOpt: typeof WaterGraphicOpt;
PolylineGraphic: typeof PolylineGraphic;
PolylineGraphicOpt: typeof PolylineGraphicOpt;
ColorStyle: typeof ColorStyle;
ArrowStyle: typeof ArrowStyle;
OutlineStyle: typeof OutlineStyle;
DashStyle: typeof DashStyle;
GlowStyle: typeof GlowStyle;
DynamicStyle: typeof DynamicStyle;
TextureStyle: typeof TextureStyle;
DynamicIconEnum: typeof DynamicIconEnum;
TextureIconEnum: typeof TextureIconEnum;
PolylineStyleEnum: typeof PolylineStyleEnum;
BezierLineGraphic: typeof BezierLineGraphic;
BezierLineGraphicOpt: typeof BezierLineGraphicOpt;
ParabolaLineGraphic: typeof ParabolaLineGraphic;
ParabolaLineGraphicOpt: typeof ParabolaLineGraphicOpt;
ArcTypeEnum: typeof ArcTypeEnum;
BubbleGraphic: typeof BubbleGraphic;
BubbleGraphicOpt: typeof BubbleGraphicOpt;
BubbleTypeEnum: typeof BubbleTypeEnum;
LabelGraphic: typeof LabelGraphic;
LabelGraphicOpt: typeof LabelGraphicOpt;
ModelGraphic: typeof ModelGraphic;
ModelGraphicOpt: typeof ModelGraphicOpt;
BillboardGraphic: typeof BillboardGraphic;
BillboardGraphicOpt: typeof BillboardGraphicOpt;
ScanGraphic: typeof ScanGraphic;
ScanGraphicOpt: typeof ScanGraphicOpt;
SensorGraphic: typeof SensorGraphic;
SensorGraphicOpt: typeof SensorGraphicOpt;
SpreadGraphic: typeof SpreadGraphic;
SpreadGraphicOpt: typeof SpreadGraphicOpt;
EllipseGraphic: typeof EllipseGraphic;
EllipseGraphicOpt: typeof EllipseGraphicOpt;
RectangleGraphic: typeof RectangleGraphic;
RectangleGraphicOpt: typeof RectangleGraphicOpt;
EllipsoidGraphic: typeof EllipsoidGraphic;
EllipsoidGraphicOpt: typeof EllipsoidGraphicOpt;
SphereGraphic: typeof SphereGraphic;
SphereGraphicOpt: typeof SphereGraphicOpt;
WallGraphic: typeof WallGraphic;
WallGraphicOpt: typeof WallGraphicOpt;
PipelineGraphic: typeof PipelineGraphic;
PipelineGraphicOpt: typeof PipelineGraphicOpt;
VolumePolylineGraphic: typeof VolumePolylineGraphic;
VolumePolylineGraphicOpt: typeof VolumePolylineGraphicOpt;
CylinderGraphic: typeof CylinderGraphic;
CylinderGraphicOpt: typeof CylinderGraphicOpt;
RadarGraphic: typeof RadarGraphic;
RadarGraphicOpt: typeof RadarGraphicOpt;
DynamicRippleGraphicOpt: typeof DynamicRippleGraphicOpt;
DynamicRippleGraphic: typeof DynamicRippleGraphic;
GraphicGroup: typeof GraphicGroup;
PolygonGraphic: typeof PolygonGraphic;
PolygonGraphicOpt: typeof PolygonGraphicOpt;
FlagGraphic: typeof FlagGraphic;
FlagGraphicOpt: typeof FlagGraphicOpt;
PluginView: typeof PluginView;
Tool: typeof Tool;
Widget: typeof Widget;
PopoverGraphic: typeof PopoverGraphic;
PopoverGraphicOpt: typeof PopoverGraphicOpt;
CircularGraphic: typeof CircularGraphic;
CircularGraphicOpt: typeof CircularGraphicOpt;
Path: typeof Path;
PathManager: typeof PathManager;
TriangleMeshGraphicOpt: typeof TriangleMeshGraphicOpt;
TriangleMeshGraphic: typeof TriangleMeshGraphic;
TerrainLayerCollection: typeof TerrainLayerCollection;
TerrainItem: typeof TerrainItem;
iCenter: typeof iCenter;
Camera: typeof Camera;
CustomLabelGraphic: typeof CustomLabelGraphic;
CustomLabelGraphicOpt: typeof CustomLabelGraphicOpt;
PlaceNameService: typeof PlaceNameService;
LabelBillboardGraphic: typeof LabelBillboardGraphic;
LabelBillboardGraphicOpt: typeof LabelBillboardGraphicOpt;
LabelRectGraphic: typeof LabelRectGraphic;
LabelRectGraphicOpt: typeof LabelRectGraphicOpt;
DePluginManager: typeof DePluginManager;
DePluginViewManager: typeof DePluginViewManager;
BilTerrainProvider: any;
TMSTerrainProvider: typeof TMSTerrainProvider;
BaiduImageryProvider: typeof BaiduImageryProvider;
GVDocument: typeof GVDocument;
DashBoardGraphic: typeof DashBoardGraphic;
DashGraphicOpt: typeof DashGraphicOpt;
BindedCylinderGraphic: typeof BindedCylinderGraphic;
BindedCylinderOpt: typeof BindedCylinderOpt;
GradientSectorGraphic: typeof GradientSectorGraphic;
GradientSectorGraphicOpt: typeof GradientSectorGraphicOpt;
CompoundImage: typeof CompoundImage;
HDVImageOption: typeof HDVImageOption;
MapSheet: typeof MapSheet;
MapBox: typeof MapBox;
MapBoxOpt: typeof MapBoxOpt;
StaticMapBox: typeof StaticMapBox;
StaticMapBoxOpt: typeof StaticMapBoxOpt;
PathPlanning: typeof PathPlanning;
PathPlanningOpt: typeof PathPlanningOpt;
ObliqueGraphic: typeof ObliqueGraphic;
ObliqueGraphicOpt: typeof ObliqueGraphicOpt;
GeoVector3: typeof GeoVector3;
PbfImageryProvider: any;
createMapBoxStyle: any;
ArcGisImagery: typeof ArcGisImagery;
ArcGisImageryOpt: typeof ArcGisImageryOpt;
BingImagery: typeof BingImagery;
BingImageryOpt: typeof BingImageryOpt;
OSMImagery: typeof OSMImagery;
OSMImageryOpt: typeof OSMImageryOpt;
UrlTemplateImagery: typeof UrlTemplateImagery;
UrlTemplateImageryOpt: typeof UrlTemplateImageryOpt;
WMSImagery: typeof WMSImagery;
WMSImageryOpt: typeof WMSImageryOpt;
WMTSImagery: typeof WMTSImagery;
WMTSImageryOpt: typeof WMTSImageryOpt;
KMLLayer: typeof KMLLayer;
KMLLayerOpt: typeof KMLLayerOpt;
GeoJsonLayer: typeof GeoJsonLayer;
GeoJsonLayerOpt: typeof GeoJsonLayerOpt;
Cesium3DTileLayer: typeof Cesium3DTileLayer;
Cesium3DTileLayerOpt: typeof Cesium3DTileLayerOpt;
BuildingMesh: typeof BuildingMesh;
ODLine: typeof ODLine;
SpreadCylinder: typeof SpreadCylinder;
SpreadCylinderOpt: typeof SpreadCylinderOpt;
DefenseEllipsoid: typeof DefenseEllipsoid;
CustomTilesetShader: typeof CustomTilesetShader;
SpecularReflection: typeof SpecularReflection;
RotatingPentahedron: typeof RotatingPentahedron;
FlowLine: typeof FlowLine;
CylinderGeometry: typeof CylinderGeometry;
FlowTube: typeof FlowTube;
FlowTubeOpt: typeof FlowTubeOpt;
DiffusionCircles: typeof DiffusionCircles;
Pentahedron: typeof Pentahedron;
TruncatedCone: typeof TruncatedCone;
ParticleOrbitingCone: typeof ParticleOrbitingCone;
EarthTheme: typeof EarthTheme;
SkyboxTheme: typeof SkyboxTheme;
ActionLayer: typeof ActionLayer;
PathAction: typeof PathAction;
CameraAction: typeof CameraAction;
VisibleAction: typeof VisibleAction;
FlickerAction: typeof FlickerAction;
FadeOutAction: typeof FadeOutAction;
ScaleAction: typeof ScaleAction;
IconGraphicOpt: typeof IconGraphicOpt;
CircleIconGraphic: typeof CircleIconGraphic;
WaveIconGraphic: typeof WaveIconGraphic;
WarnIconGraphic: typeof WarnIconGraphic;
WaterFaceGraphicOpt: typeof WaterFaceGraphicOpt;
WaterFaceGraphic: typeof WaterFaceGraphic;
AttractPointGraphic: typeof AttractPointGraphic;
AttractPointGraphicOpt: typeof AttractPointGraphicOpt;
TruncatedConeGraphic: typeof TruncatedConeGraphic;
TruncatedConeGraphicOpt: typeof TruncatedConeGraphicOpt;
TruncatedConeParticleGraphic: typeof TruncatedConeParticleGraphic;
TruncatedConeParticleGraphicOpt: typeof TruncatedConeParticleGraphicOpt;
SpreadCircleGraphic: typeof SpreadCircleGraphic;
SpreadCircleGraphicOpt: typeof SpreadCircleGraphicOpt;
SpreadCircleLineGraphic: typeof SpreadCircleLineGraphic;
SpreadCircleLineGraphicOpt: typeof SpreadCircleLineGraphicOpt;
SpreadCircleLineEnum: typeof SpreadCircleLineEnum;
SpreadCircleClampGraphic: typeof SpreadCircleClampGraphic;
SpreadCircleRampGraphic: typeof SpreadCircleRampGraphic;
SpreadCircleRampGraphicOpt: typeof SpreadCircleRampGraphicOpt;
SpreadCircleRingGraphic: typeof SpreadCircleRingGraphic;
SpreadCircleRingGraphicOpt: typeof SpreadCircleRingGraphicOpt;
SpreadCircleRingEnum: typeof SpreadCircleRingEnum;
FlowWallGraphic: typeof FlowWallGraphic;
FlowWallGraphicOpt: typeof FlowWallGraphicOpt;
DirEnum: typeof DirEnum;
GeoSotLayer: typeof GeoSotLayer;
GroundClippingAnalysis: typeof GroundClippingAnalysis;
NuclearProtectionAnalysis: typeof NuclearProtectionAnalysis;
MorphologicAnalysis: typeof MorphologicAnalysis;
MorphologicModelEnum: typeof MorphologicModelEnum;
SelectionTool: typeof SelectionTool;
BlastGraphic: typeof BlastGraphic;
BlastGraphicOpt: typeof BlastGraphicOpt;
FireGraphic: typeof FireGraphic;
FireGraphicOpt: typeof FireGraphicOpt;
FireGraphicEnum: typeof FireGraphicEnum;
ColorTable: typeof ColorTable;
CloundLayer: typeof CloundLayer;
ScreenTextGraphic: typeof ScreenTextGraphic;
ScreenTextGraphicOpt: typeof ScreenTextGraphicOpt;
FirstPersonControl: typeof FirstPersonControl;
};
/// <reference types="node" />
/**
*
*/
class BinaryParser {
constructor();
static toBinary(data: Object): Buffer;
static fromBinary(result: ArrayBuffer): any;
}
/**
*
*/
class CameraOption {
private _viewer;
constructor(viewer: Cesium.Viewer);
toJson(): any;
parseJson(config: any): void;
static defaultOption(): any;
}
class GVDocument {
private _LayerManager;
private _viewer;
private _cameraOption;
constructor(viewer: GeoCanvas);
create(): void;
toJson(): any;
/**
* json
* @param json
*/
parseJson(json: any): void;
}
/**
*
*/
class SceneData {
constructor();
static getDefaultScene(): any;
}
/**
* @类别 new iCenter()</br>
* @描述 iCenter产品中图层管理相关的操作 </br>
*/
class iCenter {
private _placeName;
private _userInfo;
private _viewer;
private _url;
private _username;
private _password;
private _icenterToken;
/**
*
* @param {GeoCanvas} viewer
* @param {string} url icenter环境地址
* @param {string} username
* @param {string} password
* ```
*
* const icenter = new GV.iCenter(viewer, 'http://icenter.geovis.online', 'admin', 'icenter');
* ```
*/
constructor(viewer: GeoCanvas, url: String, username: String, password: String);
/**
*
*/
readonly userInfo: UserInfo;
/**
*
*/
readonly placeName: PlaceName;
private _loginIcenter;
/**
*
* @param {number} page
* @param {number} pageSize
* @return
* ```
*
* icenter.getBaseImageLayers(1, 10).then(res => {
* res = {
* data: [{
* layerName: '中国',
* gridSet: 'EPSG:4326',
* mimeType: 'PNG',
* ......
* }, ......],
* total: 100,
* }
* }).catch(e => {
* console.log(e)
* });
* ```
*/
getBaseImageLayers(page: number, pageSize: number): Promise<any>;
/**
*
* @param {number} page
* @param {number} pageSize
* ```
*
* icenter.getImageLayers(1, 10).then(res => {
* console.log(res)
* }).catch(e => {
* console.log(e)
* });
*
*
* ```
*/
getImageLayers(page: number, pageSize: number): Promise<any>;
/**
*
* @param {number} page
* @param {number} pageSize
* ```
*
* icenter.getVectorLayers(1, 10).then(res => {
* console.log(res)
* }).catch(e => {
* console.log(e)
* });
*
*
* ```
*/
getVectorLayers(page: number, pageSize: number): Promise<any>;
/**
*
* @param {number} page
* @param {number} pageSize
* ```
*
* icenter.getTerrainLayers(1, 10).then(res => {
* console.log(res)
* }).catch(e => {
* console.log(e)
* });
*
*
* ```
*/
getTerrainLayers(page: number, pageSize: number): Promise<any>;
/**
*
* @param {number} page
* @param {number} pageSize
* ```
*
* icenter.getTimeImageLayers(1, 10).then(res => {
* console.log(res)
* }).catch(e => {
* console.log(e)
* });
*
*
* ```
*/
getTimeImageLayers(page: number, pageSize: number): Promise<any>;
/**
*
* @param {number} page
* @param {number} pageSize
* ```
*
* icenter.getTiltPhotoLayers(1, 10).then(res => {
* console.log(res)
* }).catch(e => {
* console.log(e)
* });
*
*
* ```
*/
getTiltPhotoLayers(page: number, pageSize: number): Promise<any>;
/**
*
* @param {number} page
* @param {number} pageSize
* ```
*
* icenter.getRealTimeLayers(1, 10).then(res => {
* console.log(res)
* }).catch(e => {
* console.log(e)
* });
* ```
*/
getRealTimeLayers(page: number, pageSize: number): Promise<any>;
/**
*
* @param {string} sourceId ID
* @param {number} minLon
* @param {number} maxLon
* @param {number} minLat
* @param {number} maxLat
* @param {number} level
* ```
*
* icenter.getClusterRealTimeData('1', 139, 39, 140, 40, 10).then(res => {
* console.log(res)
* }).catch(e => {
* console.log(e)
* });
* ```
*/
getClusterRealTimeData(sourceId: any, minLon: any, maxLon: any, minLat: any, maxLat: any, level: any): Promise<any>;
/**
*
* @param {string} sourceId ID
* @param {number} minLon
* @param {number} maxLon
* @param {number} minLat
* @param {number} maxLat
* ```
*
* icenter.getTargetRealTimeData('1', 139, 39, 140, 40).then(res => {
* console.log(res)
* }).catch(e => {
* console.log(e)
* });
* ```
*/
getTargetRealTimeData(sourceId: any, minLon: any, maxLon: any, minLat: any, maxLat: any): Promise<any>;
/**
*
* @param {object} options
* ```
*
* const provider = icenter.createBaseImageLayer({layerName: 'google-PNG-4326', gridSet: 'EPSG:4326', mimeType: 'image/png', ......});
*
* const layer = viewer.imageryLayers.addImageryProvider(provider);
* viewer.zoomTo(layer)
* ```
*/
createBaseImageLayer(options: {
layerName: string;
mimeType: string;
gridSet: string;
workspace: string;
minX: number;
minY: number;
maxX: number;
maxY: number;
}): Cesium.WebMapTileServiceImageryProvider;
/**
*
* @param {object} options
* ```
*
* const provider = icenter.createImageLayer({layerName: 'pick-PNG-4326', gridSet: 'EPSG:4326', mimeType: 'image/png', ......});
*
* const layer = viewer.imageryLayers.addImageryProvider(provider);
* viewer.zoomTo(layer)
* ```
*/
createImageLayer(options: {
layerName: string;
mimeType: string;
gridSet: string;
workspace: string;
minX: number;
minY: number;
maxX: number;
maxY: number;
}): Cesium.WebMapTileServiceImageryProvider;
/**
*
* @param {object} options
* ```
*
* const vector = icenter.createVectorLayer({layerName: 'icenter:国界线-PNG-4326', ......});
*
* viewer.tileLayer.add(vector);
* ```
*/
createVectorLayer(options: {
layerName: string;
workspace: string;
minX: number;
minY: number;
maxX: number;
maxY: number;
}): LineTile;
/**
*
* @param {object} options
* ```
*
* const provider = icenter.createTerrainLayer({layerName: 'taiwanDEM-TERRAIN-4326', minX: 119.9995833, minY: 19.9995838, maxX: 125.0004167, maxY: 25.0004171, ......});
*
* viewer.terrainProvider = provider;
* ```
*/
createTerrainLayer(options: {
layerName: string;
minX: number;
minY: number;
maxX: number;
maxY: number;
}): Cesium.CesiumTerrainProvider;
/**
*
* @param {object} options
* ```
*
* const tiltPhoto = icenter.createTiltPhotoLayer({layerName: 100, ......});
*
* tiltPhoto.readyPromise.then((tileset) => {
* viewer.scene.primitives.add(tileset);
* viewer.flyTo(tileset);
* });
* ```
*/
createTiltPhotoLayer(options: {
layerName: string;
}): Cesium.Cesium3DTileset;
}
class PlaceName {
private _viewer;
private _url;
private _username;
private _password;
private _icenterToken;
/**
*
* @param {GeoCanvas} viewer
* @param {string} url icenter环境地址
* @param {string} username
* @param {string} password
* ```
*
* const icenter = new GV.iCenter(viewer, 'http://icenter.geovis.online', 'admin', 'icenter');
* icenter.placeName
* ```
*/
constructor(viewer: GeoCanvas, url: String, username: String, password: String);
private _loginIcenter;
private _altitudeMap;
/**
*
* @param {String} placeName
* ```
*
* icenter.placeName.queryPlaceNameList('北京').then(res => {
* res = [{
* DMMC: '北京',
* WZ: 'POINT(116.400975 39.903325)',
* DMDZ: '中华人民共和国',
* ......
* }, ......]
* });
* ```
*/
queryPlaceNameList(placeName: string): Promise<any>;
/**
*
* @param {Object} options
* ```
*
* icenter.placeName.getPlaceNameLocation(options);
*
* { lon: 119, lat: 39, height: 10 }
* ```
*/
getPlaceNameLocation(options: any): {
lon: any;
lat: any;
height: number;
};
/**
*
* ```
*
* icenter.placeName.getWorldTree();
*
* [{
* name: '中国',
* }, ......]
* ```
*/
getWorldTree(): Promise<any>;
/**
*
* ```
*
* icenter.placeName.getProvinceCityCountyTree();
*
* [{
* code: 2121212,
* name: '北京',
* children: [],
* }, ......]
* ```
*/
getProvinceCityCountyTree(): Promise<any>;
/**
*
* @param {string} name
* ```
*
* icenter.placeName.getCountryArea('中国');
*
* MULTIPOLYGON (((110.88 19.99)))
* ```
*/
getCountryArea(name: string): Promise<any>;
/**
*
* @param {object} options
* ```
*
* icenter.placeName.getProvinceCityCountyArea({code: 110000, ......});
*
* MULTIPOLYGON (((110.88 19.99)))
* ```
*/
getProvinceCityCountyArea(options: any): Promise<any>;
/**
*
* ```
*
* const placeNameTile = icenter.placeName.createPlaceName();
* viewer.tileLayer.add(placeNameTile);
* ```
*/
createPlaceName(): PlaceNameTile;
}
class UserInfo {
private _url;
private _username;
private _password;
private _icenterToken;
/**
*
* @param {string} url icenter环境地址
* @param {string} username
* @param {string} password
* ```
*
* const icenter = new GV.iCenter('http://icenter.geovis.online', 'admin', 'icenter');
* icenter.userInfo
* ```
*/
constructor(url: String, username: String, password: String);
private _loginIcenter;
/**
*
* ```
*
* icenter.userInfo.getUserInfo();
* ```
*/
getUserInfo(): Promise<any>;
/**
* token
* ```
*
* icenter.userInfo.getUserToken();
* ```
*/
getUserToken(): Promise<String>;
}
const PathGroupName = "ActionPathLayer";
/**
* 使
* @param graphic
*/
function getAvailableAction(graphic: GraphicItem): any[];
class ActionGroup extends Item {
private _itemCollection;
private _startTime;
private _endTime;
private _viewer;
private _baseTime;
constructor(viewer: GeoCanvas);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
readonly length: number;
readonly rTimeBound: number[];
readonly actionCollection: ActionItem[];
setBaseTime(baseTime: Cesium.JulianDate): void;
addAction(item: ActionItem): void;
delActionInGroup(item: ActionItem): void;
delAction(item: ActionItem): void;
delActionById(itemId: string): void;
getActionById(itemId: string): ActionItem;
isContainActionId(itemId: string): boolean;
clear(): void;
moveUp(item: ActionItem): void;
moveDown(item: ActionItem): void;
calcTimeBound(): void;
calcRTimeBound(notCalcItem?: ActionItem): number[];
updateStartTimeByRST(rStartTime: number): JulianDate;
updateEndTimeByRET(rEndTime: number): JulianDate;
reCalcEndTimeByRET(notCalcItem: ActionItem, rEndTime: number): JulianDate;
reCalcStartTimeByRST(notCalcItem: ActionItem, rStartTime: number): JulianDate;
recordInitState(isAuto?: boolean): void;
pauseInExecute(): void;
continueAfterPause(): void;
stopInExecute(): void;
recoverInitState(): void;
listenerFun(currentTime: JulianDate, multiplier: number): void;
toJson(): {
actions: any[];
};
parseJson(jsonData: any): ActionItem[];
private getPathLayer;
checkGraphicStorageChange(): number;
reBindGraphicById(): void;
beforeStartInit(clock: Cesium.Clock): void;
private _toStringByDate;
private _getGraphics;
private _getRelativeGraphics;
_getGraphicById(group: GraphicGroup, id: string): any;
private _getGraphicIndex;
private _getGraphicByIndex;
}
/**
*
*/
enum ActionStateEnum {
/**
*
*/
NotStart = "notstart",
/**
*
*/
Start = "start",
/**
*
*/
Pause = "pause",
/**
*
*/
Stop = "stop",
/**
*
*/
ReStart = "restart"
}
class ActionItem extends Item {
protected _startTime: Cesium.JulianDate;
protected _endTime: Cesium.JulianDate;
protected _rStartTime: number;
protected _rEndTime: number;
protected _isDone: boolean;
protected _isFirstDone: boolean;
protected _initState: any;
protected _actionGroup: ActionGroup;
protected _viewer: GeoCanvas;
protected _properties: Object;
constructor();
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
viewer: GeoCanvas;
rStartTime: number;
rEndTime: number;
startTime: Cesium.JulianDate;
endTime: Cesium.JulianDate;
isDone: boolean;
isFirstDone: boolean;
actionGroup: ActionGroup;
properties: Object;
/**
* @description:
* @param {Cesium} currentTime
* @param {Cesium} baseTime
* @param {number} multiplier
* @return {*}
*/
timelineFun(currentTime: Cesium.JulianDate, baseTime: Cesium.JulianDate, multiplier: number): void;
recordInitState(): void;
recoverInitState(): void;
pauseEvent(): void;
stopEvent(): void;
continueEvent(): void;
}
class CameraAction extends ActionItem {
private _cameraOpt;
constructor(cameraActionOpt: CameraActionOpt);
rEndTime: number;
actionOpt: CameraActionOpt;
cameraOpt: any;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
timelineFun(currentTime: Cesium.JulianDate, baseTime: any, multiplier: any): void;
toJson(): {
name: string;
type: string;
option: {
startTime: number;
cameraOpt: any;
};
properties: Object;
};
}
class CameraActionOpt {
startTime: number;
endTime: number;
cameraOpt: any;
}
class FadeOutAction extends ActionItem {
private _graphic;
private _startTrans;
private _endTrans;
private _initColor;
private _totalTime;
private _intervalFun;
private _trans;
private _isMaterial;
private _timer;
private _materialGraphicTypes;
constructor(fadeOutActionOpt: FadeOutActionOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
startTrans: number;
/**
*
*/
endTrans: number;
graphic: GraphicItem;
rStartTime: number;
rEndTime: number;
readonly actionOpt: FadeOutActionOpt;
ationOpt: FadeOutActionOpt;
timelineFun(currentTime: Cesium.JulianDate): void;
private _parseColor;
private _createInterval;
private _clearInterval;
private _isChangeColorByMaterial;
pauseEvent(): void;
stopEvent(): void;
continueEvent(): void;
recordInitState(): void;
/**
* @ignore
* @描述:
*/
recoverInitState(): void;
toJson(): {
name: string;
type: string;
option: {
startTime: number;
endTime: number;
startTrans: number;
endTrans: number;
graphic: object;
};
properties: Object;
};
}
class FadeOutActionOpt {
/**
*
*/
startTime: number;
/**
*
*/
endTime: number;
/**
*
*/
graphic: GraphicItem;
/**
* [0,1]
*/
startTrans?: number;
/**
* [0,1]
*/
endTrans?: number;
}
class FlickerAction extends ActionItem {
private _frequency;
private _f;
private _graphic;
constructor(flickerOpt: FlickerActionOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
graphic: GraphicItem;
actionOpt: FlickerActionOpt;
frequency: number;
timelineFun(currentTime: Cesium.JulianDate, baseTime: Cesium.JulianDate): void;
recordInitState(): void;
recoverInitState(): void;
stopEvent(): void;
toJson(): {
name: string;
type: string;
option: {
startTime: number;
endTime: number;
graphic: object;
frequency: number;
};
properties: Object;
};
}
interface FlickerActionOpt {
startTime: number;
endTime: number;
graphic: GraphicItem;
frequency: number;
}
/**
* @类别
* @描述
*/
class PathAction extends ActionItem {
private _graphic;
private _path;
private _posProperty;
private _relativePosParam;
private _moveCallback;
private _isMultiNodesGraphic;
private _isNeedIntervalSingleNodeGraphic;
private _MultiNodesGraphicTypes;
private _needIntervalSingleNodeTypes;
private _intervalFun;
private _multiPosGraphicTrans;
private _specialGraphicOpt;
constructor(pathActionOpt: PathActionOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
pathActionOpt: PathActionOpt;
moveCallback: Function;
rStartTime: number;
rEndTime: number;
graphic: GraphicItem;
/**
* @description:
* ```
*
* actionObj.pathGraphic = path // 注内部对path进行拷贝,actionObj.pathGraphic在设置后产生一个新的标绘对象,设置后的actionObj.pathGraphic != path
* viewer.graphicLayer.setEditItem(actionObj.pathGraphic);
* ```
*/
pathGraphic: BezierLineGraphic | PolylineGraphic;
removePathGraphic(viewer: GeoCanvas): GraphicItem | GraphicGroup;
static getPathGraphicGroup(viewer: any): any;
initPositions(): void;
timelineFun(currentTime: Cesium.JulianDate): void;
pauseEvent(): void;
stopEvent(): void;
continueEvent(): void;
private _doMoveAction;
private _createInterval;
private _clearInterval;
private _isMultiNodes;
private _isNeedIntervalSingleNode;
private _getPathPos;
recordInitState(): void;
recoverInitState(): void;
toJson(): {
name: string;
type: string;
option: {
startTime: number;
endTime: number;
graphic: object;
path: object;
};
properties: Object;
};
}
class PathActionOpt {
graphic: GraphicItem;
startTime: number;
endTime: number;
path: BezierLineGraphic | PolylineGraphic;
relativePosParam?: {
x: number;
y: number;
z: number;
heading: number;
pitch: number;
roll: number;
};
moveCallback?: Function;
}
class ScaleAction extends ActionItem {
private _graphic;
private _factor;
private _initSize;
private _totalTime;
private _intervalFun;
private _isNeedIntervalType;
private _needIntervalTypes;
private _progress;
constructor(scaleActionOpt: ScaleActionOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
timelineFun(currentTime: Cesium.JulianDate): void;
pauseEvent(): void;
stopEvent(): void;
continueEvent(): void;
private _createInterval;
private _clearInterval;
private _isNeedInterval;
actionOpt: ScaleActionOpt;
graphic: GraphicItem;
factor: number;
rStartTime: number;
rEndTime: number;
private _getInitPixelSize;
private _changePixelSize;
recordInitState(): void;
recoverInitState(): void;
toJson(): {
name: string;
type: string;
option: {
startTime: number;
endTime: number;
graphic: object;
factor: number;
};
properties: Object;
};
}
interface ScaleActionOpt {
startTime: number;
endTime: number;
graphic: GraphicItem;
factor: number;
}
class VisibleAction extends ActionItem {
_graphic: any;
_visible: boolean;
constructor(visibleActionOpt: VisibleActionOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
graphic: GraphicItem;
actionOpt: VisibleActionOpt;
visible: boolean;
timelineFun(currentTime: Cesium.JulianDate): void;
recordInitState(): void;
recoverInitState(): void;
toJson(): {
name: string;
type: string;
option: {
startTime: number;
graphic: any;
visible: boolean;
};
properties: Object;
};
}
interface VisibleActionOpt {
startTime: number;
graphic: GraphicItem;
visible: boolean;
}
class ActionLayer {
private _state;
private _groupCollection;
private _baseTime;
private _tickListener;
private _clock;
private _multiplier;
private _viewer;
private _initCamera;
private _stopCallBack;
private _startCallBack;
private _pauseCallBack;
private _runningCB;
private _groupChangedCB;
private _isLoop;
private _currentGroupIndex;
private _groupTimeLengths;
/**
* @description:
* @param {GeoCanvas} viewer
* @param {Cesium} baseTime
* ```
*
* const baseTime = new Date()
* const actionLayer = new GV.ActionLayer(viewer, baseTime)
* ```
*/
constructor(viewer: GeoCanvas | any, baseTime?: Cesium.JulianDate | Date | String);
/**
* @description: viewer
*/
readonly viewer: GeoCanvas;
/**
* @description:
*/
/**
* @description:
* @param {boolean} isLoop
* @return {*}
*/
isLoop: boolean;
/**
* @description:
*/
readonly groupCollection: ActionGroup[];
/**
* @description:
*/
/**
* @description:
* @param {number} speed
*/
speed: number;
/**
* @description:
*/
readonly length: number;
/**
* @description:
*/
readonly actionsNum: number;
/**
* @description:
* @param {ActionItem} item
* @param {ActionGroup} actionGroup ID
* @return {*}
*/
addAction(item: ActionItem, actionGroup?: ActionGroup | string): void;
/**
* @description:
* @param {ActionItem} item
* @param {ActionGroup} actionGroup
* @return {*}
*/
delAction(item: ActionItem, actionGroup?: ActionGroup): void;
/**
* @description:
* @param {*} action
* @param {*} group
* @return {*}
*/
moveAction(action: any, group: any): void;
/**
* @description: ID删除
* @param {string} actionId ID
* @param {ActionGroup} actionGroup
* @return {*}
*/
delActionById(actionId: string, actionGroup?: ActionGroup): void;
/**
* @description:
* @param {ActionGroup} actionGroup
* @return {*}
*/
delActionGroup(actionGroup: ActionGroup): void;
/**
* @description: ID删除组
* @param {string} actionGroupById
* @return {*}
*/
delActionGroupById(actionGroupById: string): void;
/**
* @description:
* @param {*}
* @return {ActionGroup}
*/
createGroup(): ActionGroup;
/**
* @description:
* @param {ActionGroup} actionGroup
* @return {*}
*/
addActionGroup(actionGroup: ActionGroup): void;
/**
* @description: ID获取动作对象
* @param {string} actionId ID
* @param {ActionGroup} actionGroup
* @return {*}
*/
getActionById(actionId: string, actionGroup?: ActionGroup): ActionItem;
/**
* @description: ID获取动作组
* @param {string} actionGroupId
* @return {*}
*/
getGroupById(actionGroupId: string): ActionGroup;
/**
* @description: ID获取动作组
* @param {string} actionId
* @return {*}
*/
getGroupByActionId(actionId: string): ActionGroup;
/**
* @description:
* @param {*}
* @return {*}
*/
clear(): void;
/**
* @description: |
* @param {ActionItem} item
* @return {*}
*/
moveUp(item: ActionItem | ActionGroup): void;
/**
* @description: |
* @param {ActionItem} item
* @return {*}
*/
moveDown(item: ActionItem | ActionGroup): void;
/**
* @description:
* @param {*}
* @return {*}
*/
setBaseTime(baseTime: Cesium.JulianDate | Date | String, isSetAllActionGroup?: boolean): void;
/**
* @description:
* @param {*}
* @return {*}
*/
getBaseTime(): Date;
/**
* @description:
* @param {*}
* @return {*}
*/
readonly rTimeBound: number[];
/**
* @description:
* @param {*}
* @return {*}
*/
getTimeLength(): number;
/**
* @description: ID重新绑定标绘对象,
* @param {*}
* @return {*}
*/
reBindGraphicById(): void;
private _getGroupTimeLengths;
private _calcRTimeBound;
/**
* @description:
* @param {boolean} isAuto
* @return {*}
*/
start(isAuto?: boolean): void;
/**
* @description:
* @param {*}
* @return {*}
*/
pause(): void;
/**
* @description:
* @param {*}
* @return {*}
*/
reStart(): void;
/**
* @description:
* @param {*}
* @return {*}
*/
stop(): void;
/**
* @description:
* @param {*}
* @return {*}
*/
reSet(): void;
/**
* @description:
* @ignore
*/
setInitCamera(cameraOpt: any): void;
/**
* @description:
* @param {Function} startCallBack
* @return {*}
*/
onStart: () => void;
/**
* @description:
* @param {Function} pauseCallBack
* @return {*}
*/
onPause: () => void;
/**
* @description: ()
* @param {function} runningCB
* @return {*}
*/
onRunning: (rCurrentTime: number, totalRCurrentTime: number, currentTime: Cesium.JulianDate) => void;
/**
* @description: (使onRunning)
* @param {Function} runningCB
* @return {*}
*/
runningCB: (rCurrentTime: number, totalRCurrentTime: number, currentTime: Cesium.JulianDate) => void;
/**
* @description: ,
* @param {Function} groupChangedCB
* @return {*}
*/
groupChangedCB: () => void;
/**
* @description: 使
* @param {GraphicItem} graphic
* @return {Array}
*/
getAvailableAction(graphic: GraphicItem): any[];
/**
* @description:
* @param {Function} stopCallBack
* @return {*}
*/
onStop: () => void;
/**
* @description: json
* @param {boolean} isSaveGraphics
* @return {*}
*/
toJson(isSaveGraphics?: boolean): {
baseTime: string;
actionGroups: any[];
graphics: object;
} | {
baseTime: string;
actionGroups: any[];
graphics?: undefined;
};
/**
* @description: json数据
* @param {any} json
* @return {*}
*/
parseJson(json: any): ActionGroup[];
private _recordInitState;
private _beforeStartInit;
private _listenerFun;
private _clockStopFun;
private _getNextGroupIndex;
private _removeTickListener;
private _toStringByDate;
}
/**
*
*/
enum ActionStateEnum {
/**
*
*/
NotStart = "notstart",
/**
*
*/
Start = "start",
/**
*
*/
Pause = "pause",
/**
*
*/
Stop = "stop",
/**
*
*/
ReStart = "restart"
}
class CloundLayer {
private _viewer;
private scene;
private _config;
private _baseHeight;
private _brightnessShift;
private brightnessShift_;
private skyBoxshow_;
private _cloundCount;
private _maxCloundCount;
private _show;
private _rectangle;
private _option;
private _cloundColor;
private _modelCollection;
private _billboardCollection;
private _types;
constructor(viewer: Cesium.Viewer, option: any);
clamp(a: any, b: any, c: any): any;
_createClound(): void;
_initAtmosphere(): void;
_resetAtmosphere(): void;
show: boolean;
density: number;
rectangle: object;
destory(): void;
}
/**
*
* @param option
* ```
* :
* let opt = new GV.AttractPointGraphicOpt();
* opt.position = new GV.GeoPoint(112, 26);
* opt.radius = 50;
* opt.height = 300;
* let obj = new GV.AttractPointGraphic(opt);
* viewer.graphicLayer.add(obj);
*
* ```
*/
class AttractPointGraphic extends GraphicPositionItem {
constructor(opt: any);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
radius: any;
/**
*
*/
height: any;
/**
*
*/
color: any;
}
class AttractPointGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
radius: number;
/**
*
*/
height: number;
/**
*
*/
color: string;
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#plotEdit'>线</a>
*/
class BezierLineGraphic extends GraphicItem {
protected _opt: BezierLineGraphicOpt;
protected _type: string;
/**
*
* @param option
* ```
* let bezierLine = new GV.BezierLineGraphic({
* positions:[new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000), new GV.GeoPoint(100,100,200000)], //设置坐标
* lineStyle: new GV.ColorStyle({color: '#ffff00'}), //设置颜色
* width: 3, //设置宽度
* });
* viewer.graphicLayer.add(bezierLine); //添加到场景
* ```
*/
constructor(option: BezierLineGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
* @name:
* @msg:
* @param {*}
* @return {*}
*/
readonly allPositions: any[];
/**
*
* ```
*
* parabolaLine.positions = [new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)]
* ```
*/
positions: any;
/**
* 线 (单位:像素) (: >0 && <100)
* ```
*
* parabolaLine.width = 10
* ```
*/
width: number;
/**
* 线
*/
readonly clampToGround: true;
/**
* ,线 (>0 && <1000)
* ```
* parabolaLine.step = 50
* ```
*/
step: number;
/**
*
*/
dirty: boolean;
/**
* 线
* 线
* @return
* ```
* :
* parabolaLine.lineStyle = new GV.DynamicStyle({//设置动态样式
* color: '#ffff00', //颜色
* icon: GV.DynamicIconEnum.Attack, //样式图表
* duration:800 //周期
* })
* ```
*/
lineStyle: ColorStyle | ArrowStyle | OutlineStyle | DashStyle | GlowStyle | DynamicStyle;
/**
*@ignore
*/
getInterpolationCallback(value: any): GeoPoint[];
color: string;
}
/**
*
*/
class BezierLineGraphicOpt extends GraphicItemOpt {
/**
*
*/
step?: number;
/**
* 线
* 线
*/
lineStyle: ColorStyle | ArrowStyle | OutlineStyle | DashStyle | GlowStyle | DynamicStyle;
/**
*
*/
positions: Array<GeoPoint>;
/**
* 线
*/
width: number;
/**
*
*/
dirty: boolean;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#plottingBillboard'></a>
*/
class BillboardGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: BillboardGraphicOpt;
/**
*
* @param option
* ```
*
* let billboardGraphicOpt = new GV.BillboardGraphicOpt();
* billboardGraphicOpt.position = [83, 33, 500000];
* let billboardGraphic = new GV.BillboardGraphic(billboardGraphicOpt);
*
* let billboardGraphic = new GV.BillboardGraphic({...});
* ```
*/
constructor(option: BillboardGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
image: any;
/**
*
*/
scale: any;
/**
* : 'left' ; 'center' ; 'right' ;
*/
horizontalOrigin: any;
/**
* : 'baseline'线; 'bottom' ; 'center' ; 'top'
*/
verticalOrigin: any;
/**
* [x,y,z]
*/
eyeOffset: any;
/**
* [x,y] x:相对中心点屏幕横向偏移 y:相对中心点屏幕纵向偏移
*/
pixelOffset: any;
/**
*沿
*/
rotation: any;
/**
* 宽度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
width: any;
/**
* 高度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
height: any;
/**
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color: any;
scaleByDistance: any;
/**
*
*/
sizeInMeters: any;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference: any;
disableDepthTestDistance: any;
}
class BillboardGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
image: String;
/**
*
*/
scale?: number;
/**
* : 'left' ; 'center' ; 'right' ;
*/
horizontalOrigin?: String;
/**
* : 'baseline'线; 'bottom' ; 'center' ; 'top'
*/
verticalOrigin?: String;
/**
* [x,y,z]
*/
eyeOffset?: Array<number>;
/**
* [x,y] x:相对中心点屏幕横向偏移 y:相对中心点屏幕纵向偏移
*/
pixelOffset?: Array<number>;
/**
* 沿
*/
rotation?: number;
/**
* 宽度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
width: number;
/**
* 高度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
height: number;
/**
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color?: String;
scaleByDistance?: Array<number>;
/**
*
*/
sizeInMeters?: Boolean;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
disableDepthTestDistance?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cylinderRotate'></a>
*/
class BindedCylinderGraphic extends GraphicPositionItem {
protected _opt: BindedCylinderOpt;
/**
*
* @param option 沿
* ```
* :
* let bindedCylinder = new GV.BindedCylinderGraphic();
* viewer.graphicLayer.add(bindedCylinder);
*
* ```
*/
constructor(option: BindedCylinderOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @returns
*/
/**
*
* @param value
*/
color: string;
/**
*
* @returns
*/
/**
*
* @param value
*/
angle: number;
/**
*
* @param nextPosition position与下一点nextPosition组成的直线作为旋转轴
* @param horizontalAngle
* @param verticalAngle
*/
rotate(nextPosition: GeoPoint, horizontalAngle: number, verticalAngle: number): void;
/**
*
* @returns
*/
readonly nextPosition: GeoPoint;
/**
*
* @returns
*/
readonly horizontalAngle: number;
/**
*
* @returns
*/
readonly verticalAngle: number;
}
/**
*
*/
class BindedCylinderOpt extends GraphicPositionItemOpt {
/**圆锥位置,以圆锥顶部为中心 */
/**圆锥开合角 */
angle: number;
/**下一点位置 */
nextPosition: GeoPoint;
/**圆锥颜色 */
color: string;
/**水平旋转角 */
horizontalAngle: number;
/**垂直旋转角 */
verticalAngle: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#plottingPoint'></a>
*/
class BlastGraphic extends GraphicPositionItem {
protected _opt: BlastGraphicOpt;
/**
*
* @param option
* ```
*
* let point = new GV.PointGraphic({position:new GV.GeoPoint(10,10)});
* viewer.graphicLayer.add(point);
* ```
*/
constructor(option: BlastGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
startColor: any;
/**
*
*/
endColor: any;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
}
/**
*
*/
class BlastGraphicOpt extends GraphicPositionItemOpt {
/**
* CssColor
*/
startColor?: string;
/**
* CssColor
*/
endColor?: string;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#bubble'></a>
*/
class BubbleGraphic extends GraphicItem {
protected _opt: BubbleGraphicOpt;
protected _type: string;
/**
*
* @param option
* * ```
*
* let bubbleGraphicOpt = new GV.BubbleGraphicOpt();
* bubbleGraphicOpt.bindObject = new GV.GeoPoint(80, 40);
* let bubble = new GV.BubbleGraphic(bubbleGraphicOpt);
* graphicLayer.add(bubble);
* ```
*/
constructor(option: BubbleGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
bubbleType: BubbleTypeEnum;
/**
*
*/
panelOffset: {
x: number;
y: number;
};
/**
* deprecated GeoPoint对象
*/
bindObject: any;
/**
* position bindObject
*/
position: GeoPoint;
/**
* DOM,使 DOM
*/
readonly panelDom: any;
/**
* 线DOM使 DOM
*/
readonly lineDom: any;
/**
*
*/
panelDrag: boolean;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
}
/**
*
*/
class BubbleGraphicOpt extends GraphicItemOpt {
/**
*
* bubbleType为BubbleTypeEnum.FollowBubble则此参数为标牌面板相对于幕布位置
* bubbleType为BubbleTypeEnum.FixedBubble则此参数为标牌面板相对于锚点位置
*/
panelOffset: {
x: number;
y: number;
};
/**
*
*/
panelDrag: boolean;
/**
*
*/
bindObject: any;
/**
* bindObject
*/
position: GeoPoint;
/**
* Bubble类型
*/
bubbleType: BubbleTypeEnum;
visible: boolean;
}
/**
*
*/
enum BubbleTypeEnum {
FixedBubble = "fixedBubble",
FollowBubble = "followBubble"
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#geometry'></a>
*/
class CircularGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: CircularGraphicOpt;
/**
*
* @param option
* ```
*
* //绘制圆
* let circularGraphic = new GV.CircularGraphic({
* color: 'rgba(255,255,0, 0.5)',
* position: new GV.GeoPoint(0, 0, 2000),
* radius: 100000, //半径
* clampToGround: true //贴地
* });
* viewer.graphicLayer.add(circularGraphic); //添加到场景
*
* //绘制扇形
* let sector = new GV.CircularGraphic({
* color: 'rgba(255,0,0, 0.5)',
* position: new GV.GeoPoint(0, 5, 2000),
* radius: 100000, //半径
* clampToGround: false, //不贴地
* startAngle: 20, //起始角
* endAngle: 100 //终止角
* });
* viewer.graphicLayer.add(sector); //添加到场景
* ```
*/
constructor(option: CircularGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
radius: any;
/**
*(单位:角度)
*/
startAngle: any;
/**
* 单位:角度
*/
endAngle: any;
/**
*
*/
color: any;
/**
*
*/
clampToGround: any;
/**
*
*/
step: any;
}
/**
*
*/
class CircularGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
clampToGround: boolean;
/**
* m
*/
radius?: number;
/**
*(单位:角度)
*/
startAngle?: number;
/**
* 单位:角度
*/
endAngle?: number;
/**
*
*/
color?: string;
/**
* ,
*/
step?: number;
}
/**
* @类型 使
* @描述 POI绘制对象
* @see <a href='../../../examples/gallery/editor.html#textPOI'></a>
*/
class CustomLabelGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: CustomLabelGraphicOpt;
/**
*
* @param option
* ```
*
* var customLabelGraphicOpt = new GV.CustomLabelGraphicOpt();
* customLabelGraphicOpt.position = new GV.GeoPoint(0, 0);
* customLabelGraphicOpt.width = 100;
* customLabelGraphicOpt.height = 100;
* customLabelGraphicOpt.text = '星图';
* customLabelGraphicOpt.backgroundColor = 'rgba(0,0,255,1.0)';
* var customLabelGraphic = new GV.CustomLabelGraphic(customLabelGraphicOpt);
* viewer.graphicLayer.add(customLabelGraphic);
* ```
*/
constructor(option: CustomLabelGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
text: any;
/**
*
*/
scale: any;
/**
* 宽度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
width: any;
/**
* 高度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
height: any;
/**
*
*/
backgroundColor: any;
/**
* : 'baseline'线; 'bottom' ; 'center' ; 'top'
*/
verticalOrigin: any;
/**
* @ignore
*/
readonly clampToGround: boolean;
/**
* [near, far]
* label.distanceDisplayCondition = [0,1000000]
*/
distanceDisplayCondition: Array<number>;
getEditor(viewer: Cesium.Viewer, editorMgr: EditorManager): PointEditor;
}
class CustomLabelGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
text?: string;
/**
*
*/
scale?: number;
/**
* 宽度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
width?: number;
/**
* 高度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
height?: number;
/**
*
*/
backgroundColor?: string;
/**
* : 'baseline'线; 'bottom' ; 'center' ; 'top'
*/
verticalOrigin?: String;
/**
* [near, far] near和far的相机距离之间显示; near和far的单位为米;
*/
distanceDisplayCondition?: Array<number>;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cylinderSensor'></a>
*/
class CylinderDynamicGraphic extends GraphicItem {
protected _opt: CylinderDynamicGraphicOpt;
protected _type: string;
protected _renderCylinder: any;
protected _bindTop: GraphicItem;
protected _bindBottom: GraphicItem;
/**
*
* @param option
* ```
* :
* let cylinderDynamicGraphicOpt=new GV.CylinderDynamicGraphicOpt();
* let cylinder = new GV.CylinderDynamicGraphic(cylinderDynamicGraphicOpt);
* viewer.graphicLayer.add(cylinder);
* ```
*/
constructor(option: CylinderDynamicGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* PolylineCreator使用
*/
getMaxCtrlPosNum(): number;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* * @param v position属性GeoPoint类型
*
* */
/**
*
* @returns
*/
topBind: GraphicItem;
/**
*
* * @param v position属性GeoPoint类型
*
* */
/**
*
* @returns
*/
bottomBind: GraphicItem;
/**
*
* @param value
*
* */
/**
*
* @returns
*/
topPosition: GeoPoint;
/**
*
* @param value
*/
/**
*
* @returns
*/
bottomPosition: GeoPoint;
/**
*
* @param value
*/
/**
*
* @returns
*/
topRadius: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
bottomRadius: number;
/**
*
* @param value 1-5
*/
/**
*
* @returns
*
*/
speed: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
evenConeColor: string;
/**
*
* @param value
*/
/**
*
* @returns
*/
oddConeColor: string;
/**
*
* @param value
*/
/**
*
* @returns
*/
slice: number;
/**设置条纹间距 */
/**获取条纹间距 */
space: number;
positions: Array<GeoPoint>;
/**
*
*/
getCenterPosition(): GeoPoint;
movePosition(offsetLon: any, offsetLat: any, offsetAlt: any): void;
parseJson(option: any): void;
bindToJson(doc: any[]): void;
}
/**
*
*/
class CylinderDynamicGraphicOpt extends GraphicItemOpt {
/**圆柱顶面位置 */
topPosition?: GeoPoint;
/**圆柱底面位置 */
bottomPosition?: GeoPoint;
/**
*
*/
topRadius?: number;
/**
*
* */
bottomRadius?: number;
/**
* 1-5
*/
speed?: number;
/**
*
*/
evenConeColor?: string;
/**
*
*/
oddConeColor?: string;
/**相邻两个条纹之间的间距 */
space?: number;
/**
*
*/
slice?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#geometry'></a>
*/
class CylinderGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: CylinderGraphicOpt;
/**
*
* @param option
* ```
*
* let CylinderGraphic = new GV.CylinderGraphic({...});
* ```
*/
constructor(option: CylinderGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
heightReference: any;
/**
*
*/
length: any;
/**
*
*/
topRadius: any;
/**
*
*/
bottomRadius: any;
/**
*
*/
heading: any;
/**
*
*/
pitch: any;
/**
*
*/
roll: any;
/**
*
*/
fill: any;
/**
*
*/
color: any;
/**
*
*/
outline: any;
/**
*
*/
outlineColor: any;
/**
*
*/
outlineWidth: any;
/**
* 沿线
*/
numberOfVerticalLines: any;
/**
*
*/
slices: any;
/**
*
*/
shadows: any;
}
/**
*
*/
class CylinderGraphicOpt extends GraphicPositionItemOpt {
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
/**
*
*/
length: number;
/**
*
*/
topRadius: number;
/**
*
*/
bottomRadius: number;
/**
* z轴旋转
*/
heading?: number;
/**
* y轴旋转
*/
pitch?: number;
/**
* x轴旋转
*/
roll?: number;
/**
*
*/
fill?: Boolean;
/**
*
*/
color?: String;
/**
*
*/
outline?: Boolean;
/**
*
*/
outlineColor?: String;
/**
*
*/
outlineWidth?: number;
/**
* 沿线
*/
numberOfVerticalLines?: number;
/**
*
*/
slices?: number;
/**
* : 'cast_only' ; 'disabled' ; 'enabled' ; 'receive_only' ;
*/
shadows?: Boolean;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#dashEffect'></a>
*/
class DashBoardGraphic extends GraphicPositionItem {
protected _opt: DashGraphicOpt;
/**
*
* @param option
* ```
* :
* let opt = new GV.DashGraphicOpt();
* opt.dashColor = 'rgba(255.0, 0.0, 0.0, 1)';
* opt.position = new GV.GeoPoint(80, 31.85, 0);
* opt.radius = 1500;
* let dashScan = new GV.DashBoardGraphic(opt);
* viewer.graphicLayer.add(dashScan);
*
* ```
*/
constructor(option: DashGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @returns
*/
/**
*
* @param value
*/
angle: number;
/**
*
* @returns
*/
/**
*
* @param value
*/
dashColor: string;
/**
*
* @returns
*/
/**
*
* @param value
*/
radius: number;
/**
*
*/
readonly clampToGround: boolean;
}
/**
*
*/
class DashGraphicOpt extends GraphicPositionItemOpt {
/**颜色 */
dashColor?: string;
/**半径 */
radius?: number;
/**旋转角度 */
angle: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#dynamicRipple'></a>
*/
class DynamicRippleGraphic extends GraphicPositionItem {
protected _opt: DynamicRippleGraphicOpt;
/**
*
* @param option
* ```
* :
* let opt = new GV.DynamicRippleGraphicOpt();
* opt.position = new GV.GeoPoint(80, 30, 200000);
* let test = new GV.DynamicRippleGraphic(opt);
* viewer.graphicLayer.add(test);
*
* ```
*/
constructor(option: DynamicRippleGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @param value
*/
/**
*
* @returns
*/
radius: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
color: string;
/**
* 线
* @param value
*/
/**
* 线
* @returns
*/
outline: boolean;
/**
* 线
* @param value 线
*/
/**
* 线
* @returns
*/
outlineColor: string;
}
/**
*
*/
class DynamicRippleGraphicOpt extends GraphicPositionItemOpt {
/**半径 */
radius?: number;
/**颜色 */
color?: string;
/**轮廓线是否开启 */
outline?: boolean;
/**轮廓线颜色 */
outlineColor?: string;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#geometry'></a>
*/
class EllipseGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: EllipseGraphicOpt;
/**
*
* @param option
* ```
*
* let ellipseGraphic = new GV.EllipseGraphic({...});
* ```
*/
constructor(option: EllipseGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
semiMinorAxis: any;
/**
*
*/
semiMajorAxis: any;
/**
*
*/
heightReference: any;
/**
*
*/
extrudedHeight: any;
/**
* extrudedHeight相对于什么
*/
extrudedHeightReference: any;
/**
*
*/
fill: any;
/**
*
*/
color: any;
/**
* 线线1
*/
outline: any;
/**
*
*/
outlineColor: any;
/**
* 沿线
*/
numberOfVerticalLines: any;
/**
* 沿
*/
rotation: any;
/**
*
*/
stRotation: any;
/**
* 'radians_per_degree'
*/
granularity: any;
/**
*
*/
shadows: any;
}
/**
*
*/
class EllipseGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
semiMajorAxis: number;
/**
*
*/
semiMinorAxis: number;
/**
*
*/
height?: number;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
/**
*
*/
extrudedHeight?: number;
/**
* extrudedHeight的相对参考'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
extrudedHeightReference?: String;
/**
*
*/
fill?: Boolean;
/**
*
*/
color?: String;
/**
* 线1
*/
outline?: Boolean;
/**
*
*/
outlineColor?: String;
/**
* 沿线
*/
numberOfVerticalLines?: number;
/**
* 沿
*/
rotation?: number;
/**
*
*/
stRotation?: number;
/**
* degrees_per_radian: 180.0 / Math.PI; epsilon1: 0.1; epsilon2: 0.01; epsilon3: 0.001
*/
granularity?: string;
/**
* : 'cast_only' ; 'disabled' ; 'enabled' ; 'receive_only' ;
*/
shadows?: String;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#geometry'></a>
*/
class EllipsoidGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: EllipsoidGraphicOpt;
/**
*
* @param option
* ```
*
* let ellipsoidGraphic = new GV.EllipsoidGraphic({...});
* ```
*/
constructor(option: EllipsoidGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
heightReference: any;
/**
*
*/
radii: any;
/**
*
*/
fill: any;
/**
*
*/
color: any;
/**
* 线线1
*/
outline: any;
/**
*
*/
outlineColor: any;
/**
*
*/
subdivisions: any;
/**
*
*/
stackPartitions: any;
/**
*
*/
slicePartitions: any;
/**
*
*/
shadows: any;
}
/**
*
*/
class EllipsoidGraphicOpt extends GraphicPositionItemOpt {
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
/**
* [x, y, z]
*/
radii?: Array<number>;
/**
*
*/
fill?: Boolean;
/**
*
*/
color?: String;
/**
* 线1
*/
outline?: Boolean;
/**
*
*/
outlineColor?: String;
/**
*
*/
subdivisions?: number;
/**
*
*/
stackPartitions?: number;
/**
*
*/
slicePartitions?: number;
/**
* : 'cast_only' ; 'disabled' ; 'enabled' ; 'receive_only' ;
*/
shadows?: String;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#plottingPoint'></a>
*/
class FireGraphic extends GraphicPositionItem {
protected _opt: FireGraphicOpt;
/**
*
* @param option
* ```
*
* let point = new GV.PointGraphic({position:new GV.GeoPoint(10,10)});
* viewer.graphicLayer.add(point);
* ```
*/
constructor(option: FireGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
startColor: any;
/**
*
*/
endColor: any;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
*
* item.renderType = GV.FireGraphicEnum.FIRE
*/
renderType: string;
}
/**
*
*/
class FireGraphicOpt extends GraphicPositionItemOpt {
/**
* CssColor
*/
startColor?: string;
/**
* CssColor
*/
endColor?: string;
/**
* FireGraphicEnum.FIRE / FireGraphicEnum.SMKOE
*/
renderType?: string;
}
/**
*
*/
enum FireGraphicEnum {
/**
*
*/
FIRE = "fire",
/**
*
*/
SMOKE = "smoke"
}
class FirePrimitive {
private polygonHierarchy;
private modelMatrix;
show: any;
geometry: any;
vertexArray: any;
command: any;
time: any;
shaderProgram: any;
height: any;
constructor(options?: {});
createVertexArray(context: any): any;
createCommand(context: any): any;
createTexture(context: any, width: any, height: any, source: any, pixelFormat?: number, pixelDatatype?: any): any;
update(frameState: any): void;
isDestroyed(): boolean;
destroy(): void;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#plotEdit'></a>
*/
class FlagGraphic extends GraphicItem {
/**
*
*/
protected _opt: FlagGraphicOpt;
/**
*
* @param option
* ```
*
* let flagGraphic= new GV.FlagGraphic({
* position: new GV.GeoPoint(0,0,10),
* text: '这是个旗子',
* lineWidth: 3,
* color: '#ff0000'
* })
* viewer.graphicLayer.add(flagGraphic);
* ```
*/
constructor(option: FlagGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
position: any;
/**
*
*/
text: string;
/**
*
*/
scale: number;
/**
*
* 沿x方向偏移
* 沿y方向偏移
* `
*
* flagGraphic.inflectionOffset = [10,10]
* `
*/
inflectionOffset: Array<number>;
/**
*
*/
flagpoleHeight: number;
/**
* 线
*/
lineWidth: number;
/**
*
*/
textSize: number;
/**
* css颜色
*/
textColor: string;
/**
*
*/
fillColor: string;
/**
* 线
*/
color: string;
/**
* canvas相关信息
*/
getCanvasInfo(): any;
/**
* @ignore
*/
readonly clampToGround: boolean;
}
class FlagGraphicOpt extends GraphicItemOpt {
/**
* lon为经度 lat alt为高度
* ```
*
* let position = new GV.GeoPoint(-80.0, 34.0, 0.0)
* ```
*/
position: GeoPoint;
/**
*
*/
text: string;
/**
*
*/
scale?: number;
/**
*
* 沿x方向偏移
* 沿y方向偏移
*/
inflectionOffset?: Array<number>;
/**
*
*/
flagpoleHeight?: number;
/**
*
*/
textSize?: number;
/**
* css字符串
*/
textColor?: string;
/**
*
*/
fillColor?: string;
/**
* 线
*/
color?: string;
/**
* 线
*/
lineWidth?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#flowWall'></a>
*/
class FlowWallGraphic extends GraphicItem {
/**
*
*/
protected _opt: FlowWallGraphicOpt;
/**
*
* @param option
*/
constructor(option: FlowWallGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
positions: Array<GeoPoint>;
/**
*
*/
repeat: Cesium.Cartesian2;
/**
* URL
*/
image: string;
/**
*
* 1-10
*/
speed: number;
/**
*
*/
flowDir: DirEnum;
/**
*
*/
maximumHeights: any;
/**
*
*/
minimumHeights: any;
}
/**
*
*/
class FlowWallGraphicOpt {
/**
*
*/
positions: Array<GeoPoint>;
/**
*
*/
repeat: Cesium.Cartesian2;
/**
* URL
*/
image: string;
/**
*
*/
speed: number;
/**
*
*/
flowDir: DirEnum;
/**
* .[100000, 200000, 100000, 200000, 100000, 200000 ...]
*/
maximumHeights: Array<number>;
/**
* .[0, 100000, 0, 100000, 0, 100000, 0,...]
*/
minimumHeights: Array<number>;
}
/**
*
*/
enum DirEnum {
/**
*
*/
'vertical' = 1,
/**
*
*/
'horizontal' = 0
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#gradientSector'></a>
*/
class GradientSectorGraphic extends GraphicItem {
protected _opt: GradientSectorGraphicOpt;
protected _type: string;
/**
*
* @param option
* ```
* :
* let gradientSectorGraphic=new GV.GradientSectorGraphic();
* let sector = new GV.GradientSectorGraphic(GradientSectorGraphicOpt);
* viewer.graphicLayer.add(sector);
* ```
*/
constructor(option: GradientSectorGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
* @ignore
* @描述
*/
getCenterPosition(): void;
/**
* @ignore
* @描述
*/
movePosition(): void;
/**
*
* @param value
*/
/**
*
* @returns
*/
topPosition: GeoPoint;
/**
*
* @param value
*/
/**
*
* @returns
*/
bottomPosition: GeoPoint;
/**
* ,
* @returns
*/
/**
*
*/
position: GeoPoint;
/**
*
* @param value
*/
/**
*
* @returns
*/
fov: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
color: string;
/**
*
* @returns
*/
/**
*
* @param value
*/
rotation: number;
}
/**
*
*/
class GradientSectorGraphicOpt extends GraphicItemOpt {
/**顶点位置 */
topPosition?: GeoPoint;
/**底点位置 */
bottomPosition?: GeoPoint;
/**
*
*/
fov?: number;
/**
*
*/
color?: string;
rotation?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#plottingPoint'></a>
*/
class GraphicGroup extends Event {
protected _type: string;
private _name;
private _id;
private _itemList;
protected _father: GraphicGroup;
private _visible;
private _extendInfo;
private _renderVisible;
private _root;
private _clusterComputeFun;
private _clusterComputeMoveEndFun;
private _blockCompute;
private graphicClusterGroup;
private clusterWorker;
private _viewer;
private _range;
private _svg;
private _svgMap;
constructor(jsonObj?: any);
/**
*
*/
static readonly type: string;
/**
*
* ```
*
* item.name = 'itemName'
* ```
*/
name: string;
readonly id: any;
/**
*
*/
readonly father: GraphicGroup;
/**
* @注意 使
* @描述
*/
updateVisible(): void;
/**
*
*/
visible: boolean;
/**
*
*/
readonly renderVisible: any;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: any): void;
/**
* @注意
* @描述 remove方法添加时被调用
*/
destroy(): void;
/**
*
*/
clear(): void;
readonly children: Array<GraphicGroup | GraphicItem>;
extendInfo: any;
/**
*
* @param item
*/
add(item: GraphicItem | GraphicGroup): GraphicItem | GraphicGroup;
/**
*
* @param jsonObj
*/
addByJson(jsonObj: any): any;
removeById(itemId: string): GraphicItem | GraphicGroup;
/**
*
* @param
*/
remove(removeItem: GraphicItem | GraphicGroup): GraphicItem | GraphicGroup;
/**
* id获得对象
* @param itemID id
*/
getById(itemID: string): any;
/**
* name获得对象
* @param itemName
*/
getByName(itemName: string): Array<GraphicGroup | GraphicItem>;
/**
* json数据
*/
toJson(): {
type: string;
id: any;
name: string;
extendInfo: any;
children: any[];
};
bindToJson(doc: any[]): void;
/**
* @注意
* @描述 json方法json对象创建节点时调用
*/
parseJson(json: any): this;
/**
* @注意
* @描述 json方法json对象建立节点之间绑定关系时调用
*/
parseBind(json: any): void;
/**
*json添加子数据(V1.1.2)
*/
/**
* graphicLayer
*/
getRoot(): any;
/**
* position
* @param viewer
* @param range
*/
openCluster(viewer: GeoCanvas, range: number): Promise<void>;
/**
*
* @param viewer
*/
closeCluster(viewer: GeoCanvas): void;
/**
* @ignore
*
*/
initClusterCompute(viewer: any, range: any): Promise<void>;
/**
* @ignore
* svg
*/
setClusterSvg(text: any, color: any): string;
}
class GraphicItem extends Item {
private _renderVisible;
private _father;
protected _getRenderObj: any;
protected _type: any;
protected _opt: any;
protected _event: Event;
protected _isEditing: boolean;
constructor(opt: any);
protected update(): void;
/**
* @param callback
* @描述
* item.onUpdateAttribute(test)
* @注意 test
*/
onUpdateAttribute(callback: any): void;
/**
* @param callback
* @描述
* item.offUpdateAttribute(test)
* test onUpdateAttribute
* test callback
*/
offUpdateAttribute(callback: any): void;
protected updateAttribute(propName: any): void;
getRenderObject(): any;
/**
* @注意 使
* @描述
*/
updateVisible(): void;
/**
*
* ```
*
* item.name = 'itemName'
* ```
*/
name: string;
/**
* id为对象的唯一标识id不允许重复;
* ;
* id进行修改
* ```
* :
* let id = item.id;//获取对象id
* ```
*/
readonly id: any;
/**
*
*/
extendInfo: any;
/**
*
*/
visible: boolean;
/**
*
*/
readonly renderVisible: boolean;
/**
*
*/
readonly father: GraphicGroup;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @param item
*/
static isClamp(item: GraphicItem): boolean;
/**
*
*/
readonly clampToGround: boolean;
/**
*
*/
isEditing: boolean;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
bindToJson(doc: any[]): void;
/**
* json对象
*/
parseJson(option: any): void;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): any;
/**
* @注意 item的基类方法,
* @描述 remove方法添加时被调用
*/
destroy(): void;
/**
* 使
* return new LineEditor(viewer, editorMgr);
*/
getEditor(viewer: Cesium.Viewer, editorMgr: EditorManager): any;
/**
*
* Bubble
*/
getCenterPosition(): any;
/**
*
* Bubble
*/
movePosition(offsetLon?: number, offsetLat?: number, offsetAlt?: number): void;
/**
*
*
*/
clone(): GraphicItem;
}
class GraphicItemOpt {
/**
*
*/
name?: string;
/**
*
*/
visible?: boolean;
/**
*
*/
extendInfo?: any;
/**
*
*/
isEditing?: boolean;
}
/**
*
*/
enum HeightReferenceEnum {
/**
*
*/
ClampToGround,
/**
*
*/
None,
/**
* =+
*/
RelativeToGround
}
/**
*
* PointGraphicModelGraphicBillboardGraphicBindedCylinderGraphicCircularGraphic
* CustomLabelGraphicCylinderGraphicSphereGraphicLabelGraphicLabelRectGraphicDynamicRippleGraphic
* PopoverGraphicScanGraphicSensorGraphicDashBoardGraphicSpreadGraphicEllipseGraphicEllipsoidGraphic
* RadarGraphicSpreadCircleGraphic
*/
class GraphicPositionItem extends GraphicItem {
constructor(opt: any);
/**
*
* @return
* ```
*
* item.position = new GV.GeoPoint(10,10,10);
* ```
*/
position: GeoPoint;
/**
*
*/
bindObject: GraphicPositionItem;
bindToJson(doc: any[]): void;
}
class GraphicPositionItemOpt extends GraphicItemOpt {
/**
*
*/
position: GeoPoint;
/**
*
*/
bindObject?: GraphicPositionItem;
}
class BaseIconGraphic extends GraphicPositionItem {
entity: any;
protected _opt: IconGraphicOpt;
/**
*
* @param {IconGraphicOpt} options
*/
constructor(options: IconGraphicOpt);
/**
*
*/
getType(): string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* ```
* circleIcon.color=Cesium.Color.RED;
* ```
*/
color: string;
/**
*
*/
radius: number;
/**
*
* ```
* //示例
* iconGraphic.numberOfLines=3;
* ```
*/
numberOfLines: number;
/**
* ,
* ```
* //示例
* iconGraphic.duration=3000;
* ```
*/
duration: number;
/**
*
* ```
* //示例
* iconGraphic.image='./images/test.png';
* ```
*/
image: String;
/**
*
*/
readonly clampToGround: boolean;
}
class IconGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
radius: number;
/**
*
*/
numberOfLines: number;
/**
*
*/
color: string;
/**
*
*/
duration: number;
/**
*
*/
image: String;
/**
*
*/
gradient: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#icon' target="_blank"></a>
*/
class CircleIconGraphic extends BaseIconGraphic {
/**
*
* @param {IconGraphicOpt} options
* ```
* const circleOpt = new GV.IconGraphicOpt();
* circleOpt.center = new GV.GeoPoint(lon, lat);
* circleOpt.radius = 1000;
* circleOpt.numberOfLines = 4;
* circleOpt.color = Cesium.Color.AQUA;
* circleOpt.duration = 2000;
* circleOpt.gradient = 16;
* const circleIcon = new GV.CircleIconGraphic(circleOpt);
* viewer.graphicLayer.add(circleIcon);
* ```
*/
constructor(options: IconGraphicOpt);
getType(): string;
static readonly type: string;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#icon' target="_blank"></a>
*/
class WarnIconGraphic extends BaseIconGraphic {
_centerColor: string;
/**
*
* @param {IconGraphicOpt} options
* ```
* const warnOpt = new GV.IconGraphicOpt();
* warnOpt.center = new GV.GeoPoint(lon + 0.03, lat);
* warnOpt.radius = 1000;
* warnOpt.numberOfLines = 3;
* warnOpt.color = 'gold';
* warnOpt.centerColor = 'red';
* warnOpt.duration = 3000;
* warnOpt.gradient = 6;
* warnOpt.image = '../images/叹号.png'
* const warn = new GV.WarnIconGraphic(warnOpt)
* viewer.graphicLayer.add(warn);
* ```
*/
constructor(options: IconGraphicOpt);
getType(): string;
static readonly type: string;
/**
*
*/
gradient: number;
/**
*
*/
centerColor: string;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#icon' target="_blank"></a>
*/
class WaveIconGraphic extends BaseIconGraphic {
_gradient: Number;
/**
*
* @param {IconGraphicOpt} options
* ```
* const waveOpt = new GV.IconGraphicOpt();
* waveOpt.center = new GV.GeoPoint(lon + 0.01, lat + 0.02, 0);
* waveOpt.radius = 1000;
* waveOpt.numberOfLines = 3;
* waveOpt.color = Cesium.Color.AQUA;
* waveOpt.duration = 3000;
* waveOpt.gradient = 6;
* waveOpt.image = '../images/叹号.png'
* const wave = new GV.WaveIconGraphic(waveOpt)
* viewer.graphicLayer.add(wave)
* ```
*/
constructor(options: IconGraphicOpt);
/**
*
*/
gradient: Number;
getType(): string;
/**
* ()
*/
static readonly type: string;
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#plottingPointLine'>线</a>
*/
class JBLineGraphic extends GraphicItem {
protected _opt: JBLineGraphicOpt;
protected _type: string;
/**
*
* @param option
* @return
* ```
* :
* let jbLine = new GV.JBLineGraphic({
* positions:[new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)], //设置坐标
* });
* viewer.graphicLayer.add(jbLine); //添加到场景
* ```
*/
constructor(option: JBLineGraphicOpt);
/**
*
*/
code: string;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* ```
*
* jbLine.positions = [new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)]
* ```
*/
positions: Array<GeoPoint>;
/**
* 线
*/
lineWidth: number;
/**
*
*/
dirty: boolean;
/**
*
*/
/**
*
*/
height: number;
/**
*
*/
/**
*
*/
supplementFlag: boolean;
/**
* 线
*/
/**
* 线
*/
lineColor: string;
/**********适应之前所修改 begin*/
/**
* 线
*/
/**
* 线
*/
color: string;
/**********适应之前所修改 end*/
/**
*
*/
/**
*
*/
renderMode: JBRenderModeEnum;
/**
*
*/
/**
*
*/
fillFlag: boolean;
/**
*
*/
/**
*
*/
fillStartColor: string;
/**
*
*/
/**
*
*/
fillEndColor: string;
/**
*
*/
/**
*
*/
fillAngle: number;
/**
*
*/
/**
*
*/
supplementColor: string;
/**
* , false 线
*/
isUnique: boolean;
/**
* @ignore
*/
readonly clampToGround: boolean;
}
/**
* 线
*/
class JBLineGraphicOpt extends GraphicItemOpt {
/**
*
*/
code: string;
/**
*
*/
positions: Array<GeoPoint>;
/**
* 线
*/
lineWidth?: number;
/**
* 线
*/
lineColor?: string;
/**注lineColor与color一致 */
/**线的颜色 */
color?: string;
/**
*
*/
dirty: boolean;
/**
*
*/
height: number;
/**
*
*/
supplementFlag: boolean;
/**
* 'raster' 'vector'
*/
renderMode: JBRenderModeEnum;
/**是否填充 */
fillFlag: boolean;
/**起点填充颜色 */
fillStartColor: string;
/**终点填充颜色 */
fillEndColor: string;
/**渐变偏角 */
fillAngle: number;
/**拉伸网格体颜色 */
supplementColor: string;
/**是否非闭合 */
isUnique: boolean;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#jbPointRender'>JB点</a>
*/
class JBPointGraphic extends GraphicItem {
protected _opt: JBPointGraphicOpt;
protected _type: string;
/**
*
* @param option
* @return
* ```
* :
* let group = new GV.GraphicGroup();
* viewer.graphicLayer.add(group);
* let point = new GV.JBPointGraphic({
* code: '10-200-0',//军标码
* position:new GV.GeoPoint(i,j,0),//位置点
* size:0.5,//大小,
* color: '#ffff00'
* });
* group.add(point);
* ```
*/
constructor(option: JBPointGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* ```
*
* jbPoint.position = new GV.GeoPoint(0,0,200000);
* ```
*/
position: GeoPoint;
/**
*
*/
code: string;
/**
* 线
*/
color: string;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
rotation: number;
/**
*
*/
size: number;
/**
* #F66
*/
strokeColor: string;
/**
* 0 0
*/
strokeWidth: number;
/**
*
*/
renderMode: JBRenderModeEnum;
/**
*
* ```
*
* point.imageOffset={'x':50,'y':50}
* ```
*/
imageOffset: {
x: number;
y: number;
};
/**
*
*/
textOffset: {
x: number;
y: number;
};
/**
*
*/
text: string;
/**
*
*/
textFont: string;
/**
*
*/
textColor: string;
/**
*
*/
textSize: number;
/**
*
*/
textBackgroundColor: string;
/**
*
*/
textScale: number;
/**
* , RASTER
*/
height: number;
/**
*
*/
vectorExtrudedHeight: number;
/**
*
* @ignore
*/
/**
* @ignore
*/
fillColor: string;
/**
* @ignore
*/
readonly clampToGround: boolean;
/**
* @ignore
*/
pixelOffset: Cesium.Cartesian2;
/**
*
*/
flagText: string;
/**
*
*/
flagTextSize: number;
/**
*
*/
flagTextSpace: number;
/**
*
*/
flagTextFont: string;
/**
*
*/
flagTextColor: string;
/**
*
*/
flagTextBgColor: string;
/**
* 线
*/
trailLineShow: any;
/**
* 线GV.ColorStyle,GV.DashStyle,GV.OutlineStyle
*/
trailLineColor: any;
/**
* 线
*/
trailLineWidth: any;
/**
* 线
*/
enableTrailDrag: any;
/**
* 线
*/
flagInnerStrokeWidth: any;
/**
* 线
*/
flagInnerStrokeColor: any;
}
/**
*
*/
class JBPointGraphicOpt extends GraphicItemOpt {
/**
*
*/
code: string;
/**
*
*/
position: GeoPoint;
/**
*
*/
color?: string;
/**
*
*/
size?: number;
/**
*
*/
rotation?: number;
/**
*
*/
dirty: boolean;
/**
* #F66
*/
strokeColor?: string;
/**
* 0
*/
strokeWidth?: number;
/**
*
*/
renderMode?: JBRenderModeEnum;
/**
*
*/
textOffset?: {
x: number;
y: number;
};
/**
*
*/
imageOffset?: {
x: number;
y: number;
};
/**
*
*/
text?: string;
/**
*
*/
textFont?: string;
/**
*
*/
textSize?: number;
/**
*
*/
textColor?: string;
/**
*
*/
textBackgroundColor?: string;
/**
*
*/
textScale?: number;
/**
* RASTER
*/
height?: number;
/**
*
*/
vectorExtrudedHeight?: number;
/**
*
* @ignore
*/
fillColor?: string;
/**
*
*/
flagText?: string;
/**
*
*/
flagTextSize?: number;
/**
*
*/
flagTextSpace?: number;
/**
*
*/
flagTextFont?: string;
/**
*
*/
flagTextColor?: string;
/**
*
*/
flagTextBgColor?: string;
/**
* 线 true
*/
trailLineShow: boolean;
/**
* 线
*/
trailLineColor?: string;
/**
* 线
*/
trailLineWidth: number;
/**
* trailLineShow true时有效
*/
enableTrailDrag: boolean;
/**
* 线
*/
flagInnerStrokeWidth: number;
/**
* 线
*/
flagInnerStrokeColor: string;
}
enum JBRenderModeEnum {
/**
* JBLineGraphic
*/
VECTOR = "VECTOR",
/**
* JBLineGraphic JBPointGraphic
*/
RASTER = "RASTER",
/**
* billboard JBPointGraphic
*/
BILLBOARD = "BILLBOARD"
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#popover'></a>
*/
class LabelBillboardGraphic extends GraphicItem {
/**
*
*/
protected _opt: LabelBillboardGraphicOpt;
/**
*
*/
protected _type: string;
/**
*
* @param option
* ```
*
* let label = new GV.LabelBillboardGraphic({
* position: new GV.GeoPoint(-80.0, 34.0, 0.0),
* moveX: 0,
* moveY: -100
* });
* viewer.graphicLayer.add(label);
* ```
*/
constructor(option: LabelBillboardGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
* @param move
*/
updateCanvas(move: any): void;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
position: any;
/**
*
*/
/**
*
*/
scale: any;
/**
* [x,y,z]
*/
eyeOffset: any;
/**
* [x,y] x:相对中心点屏幕横向偏移 y:相对中心点屏幕纵向偏移
*/
/**
*沿
*/
rotation: any;
/**
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color: any;
scaleByDistance: any;
/**
*
*/
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference: any;
/**
*
*/
canvasWidth: any;
/**
*
*/
/**
* X
*/
moveX: any;
/**
* Y
*/
moveY: any;
/**
*
*/
text: any;
/**
*
*/
fontSize: any;
/**
*
*/
lineHeight: any;
/**
*
*/
topbottomOpenningLeft: any;
/**
*
*/
topbottomOpenningRight: any;
/**
*
*/
leftrightOpenningTop: any;
/**
*
*/
leftrightOpenningBottom: any;
/**
*
*/
fontColor: any;
/**
* [near, far] near和far的相机距离之间显示; near和far的单位为米; [10,100]
*/
distanceDisplayCondition: Array<number>;
}
class LabelBillboardGraphicOpt extends GraphicItemOpt {
/**
* lon为经度 lat alt
* ```
*
* let position = new GV.GeoPoint(-80.0, 34.0, 0.0)
* ```
*/
position: GeoPoint;
/**
*
*/
scale?: number;
/**
* [x,y,z]
*/
eyeOffset?: Array<number>;
/**
* [x,y] x:相对中心点屏幕横向偏移 y:相对中心点屏幕纵向偏移
*/
/**
* 沿
*/
rotation?: number;
/**
* '#ff0000'
*/
color?: string;
scaleByDistance?: Array<number>;
/**
*
*/
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
/**
* [near, far] near和far的相机距离之间显示; near和far的单位为米; [10,100]
*/
distanceDisplayCondition?: Array<number>;
/**
*
*/
canvasWidth?: number;
/**
*
*/
/**
* X
*/
moveX?: number;
/**
* Y
*/
moveY?: number;
/**
*
*/
text?: string;
/**
*
*/
fontSize?: number;
/**
*
*/
fontColor?: string;
/**
*
*/
lineHeight?: number;
/**
*
*/
topbottomOpenningLeft?: number;
/**
*
*/
topbottomOpenningRight?: number;
/**
*
*/
leftrightOpenningTop?: number;
/**
*
*/
leftrightOpenningBottom?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#plottingText'></a>
*/
class LabelGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: LabelGraphicOpt;
/**
*
* @param option
* ```
*
* let labelGraphicOpt = new GV.LabelGraphicOpt();
* labelGraphicOpt.position = [83, 33, 500000];
* let labelGraphic = new GV.LabelGraphic(labelGraphicOpt);
*
* let labelGraphic = new GV.LabelGraphic({...});
* ```
*/
constructor(option: LabelGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
text: any;
/**
*
*/
scale: any;
/**
* : 'left' ; 'center' ; 'right' ;
*/
horizontalOrigin: any;
/**
* : 'baseline'线; 'bottom' ; 'center' ; 'top'
*/
verticalOrigin: any;
/**
*
*/
eyeOffset: any;
/**
*
*/
pixelOffset: any;
/**
* 线
*/
outlineWidth: any;
/**
*
*/
font: any;
/**
*
*/
style: any;
/**
*
*/
fillColor: any;
/**
*
*/
outlineColor: any;
/**
*
*/
backgroundColor: any;
/**
*
*/
scaleByDistance: any;
/**
*
*/
pixelOffsetScaleByDistance: any;
/**
*
*/
showBackground: any;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference: any;
/**
*
*/
translucencyByDistance: any;
/**
*
*/
isDepthTest: boolean;
/**
* [near, far]
* label.distanceDisplayCondition = [0,1000000]
*/
distanceDisplayCondition: Array<number>;
}
class LabelGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
text: String;
/**
*
*/
scale?: number;
/**
* : 'left' ; 'center' ; 'right' ;
*/
horizontalOrigin?: String;
/**
* : 'baseline'线; 'bottom' ; 'center' ; 'top'
*/
verticalOrigin?: String;
/**
* [x,y,z]
*/
eyeOffset?: Array<number>;
/**
* [x,y] x:相对中心点屏幕横向偏移 y:相对中心点屏幕纵向偏移
*/
pixelOffset?: Array<number>;
/**
* 线
*/
outlineWidth?: number;
/**
* css字体设置
*/
font?: String;
/**
* 'fill' ,fill_and_outline , outline
*/
style?: String;
/**
* 填充颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
fillColor?: String;
/**
* 轮廓颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
outlineColor?: String;
/**
* 背景颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
backgroundColor?: String;
/**
*
*/
scaleByDistance?: Array<number>;
/**
*
*/
pixelOffsetScaleByDistance?: Array<number>;
/**
*
*/
showBackground?: Boolean;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
/**
*
*/
translucencyByDistance?: number;
/**
*
*/
isDepthTest?: boolean;
/**
* [near, far] near和far的相机距离之间显示; near和far的单位为米;
* labelGraphic.distanceDisplayCondition = [0,5000000]
*/
distanceDisplayCondition?: Array<number>;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#popover'></a>
*/
class LabelRectGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: LabelRectGraphicOpt;
/**
*
* @param option
* ```
*
* let labelRect = new GV.LabelRectGraphic({
* position: new GV.GeoPoint(-80.0, 34.0, 0.0),
* text:"我是文本我是文本我是文本我是文本我是文本我是文本我是文本我是文本"
* });
* viewer.graphicLayer.add(labelRect);
* ```
*/
constructor(option: LabelRectGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
* @param move
*/
updateCanvas(): void;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
scale: any;
/**
* [x,y,z]
*/
eyeOffset: any;
/**
*沿
*/
rotation: any;
/**
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color: any;
/**
*
*/
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference: any;
/**
*
*/
canvasWidth: any;
/**
*
*/
text: any;
/**
*
*/
font: any;
/**
*
*/
fontSize: any;
/**
*
*/
fontColor: any;
/**
*
*/
bold: any;
/**
*
*/
lineHeight: any;
/**
* [near, far] near和far的相机距离之间显示; near和far的单位为米; [10,100]
*/
distanceDisplayCondition: any;
getEditor(viewer: Cesium.Viewer, editorMgr: EditorManager): PointEditor;
}
class LabelRectGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
scale?: number;
/**
* [x,y,z]
*/
eyeOffset?: Array<number>;
/**
* [x,y] x:相对中心点屏幕横向偏移 y:相对中心点屏幕纵向偏移
*/
/**
* 沿
*/
rotation?: number;
/**
* '#ff0000'
*/
color?: string;
/**
*
*/
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
/**
* [near, far] near和far的相机距离之间显示; near和far的单位为米; [10,100]
*/
distanceDisplayCondition?: Array<number>;
/**
*
*/
canvasWidth?: number;
/**
*
*/
text?: string;
/**
*
*/
font?: string;
/**
*
*/
fontSize?: number;
/**
*
*/
fontColor?: string;
/**
*
*/
bold?: boolean;
/**
*
*/
lineHeight?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#model'></a>
*/
class ModelGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: ModelGraphicOpt;
/**
*
* @param option
* ```
*
* let modelGraphicOpt = new GV.ModelGraphicOpt();
* modelGraphicOpt.position = [83, 33, 500000];
* let modelGraphic = new GV.ModelGraphic(ModelGraphicOpt);
*
* let modelGraphic = new GV.ModelGraphic({...});
* ```
*/
constructor(option: ModelGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
url: any;
/**
*
*/
scale: any;
/**
*
*/
heading: any;
/**
*
*/
pitch: any;
/**
*
*/
roll: any;
/**
*
*/
minimumPixelSize: any;
/**
*
*/
maximumScale: any;
/**
*
*/
runAnimations: any;
/**
*
*/
clampAnimations: any;
/**
*
*/
silhouetteColor: any;
/**
*
*/
silhouetteSize: any;
/**
*
*/
color: any;
/**
*
*/
heightReference: any;
}
/**
*
*/
class ModelGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
url: String;
/**
*
*/
scale?: number;
/**
* z轴旋转
*/
heading?: number;
/**
* y轴旋转
*/
pitch?: number;
/**
* x轴旋转
*/
roll?: number;
/**
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color?: String;
/**
*
*/
minimumPixelSize: number;
/**
* minimumPixelSize的上限
*/
maximumScale?: number;
/**
* glTF动画
*/
runAnimations?: Boolean;
/**
* glTF动画是否应保留最后一个没有关键帧的持续时间姿势
*/
clampAnimations?: Boolean;
/**
* 模型轮廓颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
silhouetteColor?: String;
/**
*
*/
silhouetteSize?: number;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
}
/**
* @类型 使
* @描述 3dTiles模型规范对象 3dtiles
* @see <a href='../../../examples/gallery/editor.html#edit3dTile'>3Dtiles </a>
*/
class ObliqueGraphic extends GraphicItem {
/**
*
*/
protected _opt: ObliqueGraphicOpt;
/**
*
*/
protected _type: string;
/**
*
* @param option
* ```
*
* let obliqueGraphicOpt = new GV.ObliqueGraphicOpt();
* obliqueGraphicOpt.url = qxmoUrl;
* let tileset = new GV.ObliqueGraphic(obliqueGraphicOpt);
*
* let tileset = new GV.ObliqueGraphic({
* url: qxmoUrl
* ...
* })
* ```
*/
constructor(option: ObliqueGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
*/
getType(): string;
/**
*
*/
getCenterPosition(): GeoPoint;
/**
* ()
*/
static readonly type: string;
/**
*
*/
movePosition(offsetLon: any, offsetLat: any, offsetAlt: any): void;
/**
* 3dtiles模型地址路径
*/
url: any;
/**
*
*/
scale: any;
/**
*
*/
offset: any;
/**
*
*/
rotate: any;
/**
* @ignore
*
*/
/**
* @ignore
*/
color: any;
/**
*
*/
isEditing: any;
/**
* @ignore
*/
readonly clampToGround: boolean;
}
/**
*
*/
class ObliqueGraphicOpt extends GraphicItemOpt {
/**
*
*/
url: string;
/**
* @ignore
*
*/
scale?: number;
/**
* [x,y,z]
*/
offset?: Array<number>;
/**
* [x,y,z]
*/
rotate?: Array<number>;
/**
* @ignore
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color?: string;
/**
*
*/
isEditing?: boolean;
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#polylineArrow'>线</a>
*/
class ParabolaLineGraphic extends GraphicItem {
protected _opt: ParabolaLineGraphicOpt;
protected _type: string;
/**
*
* @param option
* ```
* :
* let parabolaLine = new GV.ParabolaLineGraphic({
* positions:[new GV.GeoPoint(80,10,20000), new GV.GeoPoint(110,0,200000)],
* lineStyle: new GV.DynamicStyle({
* color: '#00FF99',
* icon: GV.DynamicIconEnum.Arrow,
* duration:1000
* }),
* width:5, //线宽
* factor: 50000,
* step: 50
* });
* graphicLayer.add(parabolaLine)
* ```
*/
constructor(option: ParabolaLineGraphic);
/**
*
*/
getType(): string;
/**
* PolylineCreator使用
*/
getMaxCtrlPosNum(): number;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* ```
*
* parabolaLine.positions = [new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)]
* ```
*/
positions: any;
readonly interpolation: boolean;
/**
* 线 (单位:像素) (: >0 && <100)
* ```
*
* parabolaLine.width = 10
* ```
*/
width: number;
/**
* 线 >0 && <10000000
* ```
*
* parabolaLine.factor = 50000
* ```
*/
factor: number;
/**
* ,线 (>0 && <1000)
* ```
* parabolaLine.step = 50
* ```
*/
step: number;
readonly clampToGround: boolean;
/**
*
*/
dirty: boolean;
/**
* 线
* 线
* @return
* ```
* :
* parabolaLine.lineStyle = new GV.DynamicStyle({//设置动态样式
* color: '#ffff00', //颜色
* icon: GV.DynamicIconEnum.Attack, //样式图表
* duration:800 //周期
* })
* ```
*/
lineStyle: ColorStyle | ArrowStyle | OutlineStyle | DashStyle | GlowStyle | DynamicStyle;
color: string;
/**
* @注意
*
*
* @param value
*/
getInterpolationCallback(value: any): any[];
}
/**
* 线
*/
class ParabolaLineGraphicOpt extends GraphicItemOpt {
/**
* 线
* 线
*/
lineStyle?: ColorStyle | ArrowStyle | OutlineStyle | DashStyle | GlowStyle | DynamicStyle;
/**
*
*/
factor?: number;
/**
*
*/
step?: number;
/**
* 线
*/
positions?: Array<GeoPoint>;
/**
* 线
*/
width?: number;
/**
*
*/
dirty: boolean;
/**
*
*/
clampToGround?: boolean;
/**
* true为只接受两个控制点
*/
interpolation?: boolean;
}
class PipelineBaseGraphic extends GraphicItem {
protected _opt: PipelineBaseGraphicOpt;
protected _rectangle: Cesium.Rectangle;
constructor(option: PipelineBaseGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
PipeType(): PipeType;
getCenterLine(): any;
/**
*
*/
updateRender(): void;
/**
* 便
*/
readonly bounding: Cesium.Rectangle;
image: any;
color: any;
showOutline: any;
outlineColor: any;
/**
*
* @param geoPoints
*/
protected updateBounding(geoPoints: Array<GeoPoint>): void;
}
class PipelineBaseGraphicOpt extends GraphicItemOpt {
/**
*
*/
image?: string;
/**
* 使
*/
color?: string;
/**
* 线
*/
showOutline?: boolean;
/**
* 线
*/
outlineColor?: string;
}
enum PipeType {
PipeBase = 1,
PipelineStripGraphic = 2,
PipelineTurnGraphic = 3,
PipeTurnTwoGraphic = 4,
PipeTurnThreeGraphic = 5,
PipelineGraphic = 100
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#PipeLine'>线</a>
*/
class PipelineGraphic extends PipelineBaseGraphic {
protected _opt: PipelineGraphicOpt;
protected _renderPara: {
lineSeg: Array<Cesium.Cartesian3>;
cornerSeg: Array<object>;
centerPts: Array<Cesium.Cartesian3>;
};
protected _type: string;
/**
*
* @param option
* @return
* ```
* :
* let polyline = new GV.PipelineGraphic({
* positions:[new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)], //设置坐标
* radius: 10 //管道半径
* });
* viewer.graphicLayer.add(polyline); //添加到场景
* ```
*/
constructor(option: PipelineGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
PipeType(): PipeType;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* ```
*
* polyline.positions = [new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)]
* ```
*/
positions: Array<GeoPoint>;
radius: any;
shape: any;
/**
* 线线ptscorners
* @param cornerRadius
*/
protected updateRenderPara(cornerRadius?: number): void;
/**
*
* object对象
* {
* lineSeg:Array<Cesium.Cartesian3>, //直线段部分顶点
* cornerSeg:Array<object>, //拐弯部分顶点
* centerPts:Array<Cesium.Cartesian3> //中心线顶点
* }
*/
getRenderPara(): {
lineSeg: Cesium.Cartesian3[];
cornerSeg: object[];
centerPts: Cesium.Cartesian3[];
};
getCenterLine(): any[];
}
enum SectionShape {
Circle = "circle",
Rect = "rect",
RoundRect = "roundRect"
}
class PipelineGraphicOpt extends PipelineBaseGraphicOpt {
/**
*
*/
positions: Array<GeoPoint>;
/**
*
*/
radius: number;
/**
*
*/
shape: SectionShape;
}
class PipelineStripGraphic extends PipelineBaseGraphic {
private _headTopoNode;
private _tailTopoNode;
protected _opt: PipelineGraphicOpt;
protected _renderPara: {
geos: Array<GeoPoint>;
pts: Array<Cesium.Cartesian3>;
types: Array<boolean>;
};
protected _type: string;
/**
*
* @param option
* @return
* ```
* :
* let polyline = new GV.PipelineStripGraphic({
* positions:[new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)], //设置坐标
* radius: 10 //管道半径
* });
* viewer.graphicLayer.add(polyline); //添加到场景
* ```
*/
constructor(option: PipelineGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
PipeType(): PipeType;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* ```
*
* polyline.positions = [new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)]
* ```
*/
positions: Array<GeoPoint>;
radius: any;
shape: any;
/**
*
*/
headTopoNode: any;
/**
*
*/
tailTopoNode: any;
/**
* 线线ptscorners
* @param cornerRadius
*/
private updateRenderPara;
/**
*
*/
getPositions(): any[];
/**
* 线
* {
* geos:Array<GeoPoint>, //中心线地理坐标
* pts:Array<Cesium.Cartesian3>, //中心线世界坐标
* types:Array<boolean> //中心线类型true表示直线段false表示曲线段
* }
*/
getRenderParas(): {
geos: GeoPoint[];
pts: Cesium.Cartesian3[];
types: boolean[];
};
getCenterLine(): any[];
updateRender(): void;
}
class PipelineTurnGraphic extends PipelineBaseGraphic {
protected _opt: PipelineTurnGraphicOpt;
constructor(option: PipelineTurnGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
PipeType(): PipeType;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
position: GeoPoint;
center: GeoPoint;
radius: any;
shape: any;
directions: Array<GeoPoint>;
protected updateRenderPara(cornerRadius?: number): void;
}
class PipelineTurnGraphicOpt extends PipelineBaseGraphicOpt {
/**
*
*/
center: GeoPoint;
/**
*
*/
radius: number;
/**
*
*/
shape: SectionShape;
/**
* 线PipelineStripGraphic中的线段顶点
*/
directions: Array<GeoPoint>;
}
class PipeTurnThreeGraphic extends PipelineTurnGraphic {
protected _opt: PipelineTurnGraphicOpt;
/**
* index:PipelineStripGraphic对象在列表中的索引
* angle:与下一段相邻线的夹角
* pt:线段终点
* centerPts:插值后的完整中心线
* centerTypes:线段类型true表示直线段false表示曲线段线centerPts1
*/
protected _turnArray: Array<{
index: number;
angle: number;
pt: GeoPoint;
centerPts: Array<Cesium.Cartesian3>;
centerTypes: Array<boolean>;
}>;
constructor(option: PipelineTurnGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
PipeType(): PipeType;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
protected updateRenderPara(cornerRadius?: number): void;
/**
* 线
* object{index: number, angle:number, pt:GeoPoint, centerPts:Array<Cesium.Cartesian3>, centerTypes: Array<boolean>
* object对象包含了某条线段与其逆时针方向的相邻线段的拐弯参数
* index:当前线段载体PipelineStripGraphic对象
* angle:与相邻线的夹角
* pt:当前线段的终点
* centerPts:插值后的完整中心线
* centerTypes:线段类型true表示直线段false表示曲线段线centerPts1
*/
getTurnArray(): {
index: number;
angle: number;
pt: GeoPoint;
centerPts: Cesium.Cartesian3[];
centerTypes: boolean[];
}[];
}
class PipeTurnTwoGraphic extends PipelineTurnGraphic {
protected _opt: PipelineTurnGraphicOpt;
protected _centerPts: Array<Cesium.Cartesian3>;
constructor(option: PipelineTurnGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
PipeType(): PipeType;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
protected updateRenderPara(cornerRadius?: number): void;
/**
* 线
*/
getCenterPts(): Cesium.Cartesian3[];
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#plottingPoint'></a>
*/
class PointGraphic extends GraphicPositionItem {
protected _opt: PointGraphicOpt;
/**
*
* @param option
* ```
*
* let point = new GV.PointGraphic({position:new GV.GeoPoint(10,10)});
* viewer.graphicLayer.add(point);
* ```
*/
constructor(option: PointGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* () >0 && <100
*/
pixelSize: number;
/**
*
*/
color: any;
/**
*
*/
outlineColor: any;
/**
*
*/
outlineWidth: any;
/**
*
*/
heightReference: any;
/**
*
*/
scaleByDistance: any;
/**
*
*/
isDepthTest: boolean;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
}
/**
*
*/
class PointGraphicOpt extends GraphicPositionItemOpt {
/**
* (单位:像素) (: >0 && <500)
*/
pixelSize?: number;
/**
* CssColor
*/
color?: string;
/**
* (单位:像素) (: >0 && <500)
*/
outlineWidth?: number;
/**
* CssColor
*/
outlineColor?: string;
/**
*
*/
scaleByDistance?: Array<Number>;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: string;
/**
*
*/
isDepthTest?: boolean;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#polygon'></a>
*/
class PolygonGraphic extends GraphicItem {
protected _opt: PolygonGraphicOpt;
protected _type: string;
/**
*
* @param option
* @return
* ```
* :
* let polygon = new GV.PolygonGraphic({
* positions:[new GV.GeoPoint(0,10), new GV.GeoPoint(0,20),new GV.GeoPoint(10,20),new GV.GeoPoint(10,0)] //设置坐标
* holes:[[GV.GeoPoint(3,13), GV.GeoPoint(7,13), GV.GeoPoint(5,18)]] //带一个洞
* });
* viewer.graphicLayer.add(polygon); //添加到场景
* ```
*/
constructor(option: PolygonGraphicOpt);
/**
*
*/
getType(): string;
/**
* PolylineCreator使用2
*/
getMinCtrlPosNum(): number;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
positions: any;
holes: any;
/**
* clampToGround为true时无效
*/
height: any;
/**
* clampToGround为true时无效
*/
extrudedHeight: any;
/**
* 使
*/
fill: any;
/**
*
*/
color: any;
/**
*
*/
outline: any;
/**
*
*/
outlineColor: any;
/**
*
*/
outlineWidth: any;
/**
* @只读 clampToGround为true时无效
* @描述 使 extrudedHeight 0
* ```
*
* let polygon = new GV.PolygonGraphic({
* positions:[new GV.GeoPoint(0,10,5000), new GV.GeoPoint(0,20,200000),new GV.GeoPoint(10,20,300000),new GV.GeoPoint(10,0,200000)], //设置坐标
* extrudedHeight : 0,
* perPositionHeight : true
* });
* viewer.graphicLayer.add(polygon); //添加到场景
* ```
*/
readonly perPositionHeight: boolean;
/**
* clampToGround为true时无效
* ```
*
* let polygon = new GV.PolygonGraphic({
* positions:[new GV.GeoPoint(0,10, 100000), new GV.GeoPoint(0,20, 100000),new GV.GeoPoint(10,20, 100000),new GV.GeoPoint(10,0, 100000)], //设置坐标
* clampToGround : false,
* extrudedHeight : 500000.0,
* closeTop : false,
* closeBottom : false
* });
* viewer.graphicLayer.add(polygon); //添加到场景
* ```
*/
closeTop: any;
/**
* clampToGround为true时无效
*/
closeBottom: any;
/**
*
* heightextrudedHeightperPositionHeightcloseTopcloseBottom参数无效
*/
clampToGround: boolean;
/**
*
*/
dirty: boolean;
movePosition(offsetLon?: number, offsetLat?: number, offsetAlt?: number): void;
/**
* video dom
*/
videoElement: HTMLVideoElement;
/**
* video dom
*/
stRotation: number;
/**
* video viewer clock
*/
bindClock: boolean;
/**
* [x,y] x y方向重复数
*/
repeat: Array<number>;
}
/**
*
*/
class PolygonGraphicOpt extends GraphicItemOpt {
clampToGround?: boolean;
/**
*
*/
positions: Array<GeoPoint>;
/**
*
*/
holes?: Array<Array<GeoPoint>>;
/**
*
*/
height?: number;
/**
*
*/
extrudedHeight?: number;
/**
*
*/
fill?: boolean;
/**
*
*/
color?: string;
/**
*
*/
outline?: boolean;
/**
*
*/
outlineColor?: string;
/**
* 线
*/
outlineWidth?: number;
/**
* 使
*/
perPositionHeight?: boolean;
/**
*
*/
closeTop?: boolean;
/**
*
*/
closeBottom?: boolean;
/**
*
*/
dirty?: boolean;
/**
* dom
*/
videoElement?: HTMLVideoElement;
/**
*
*/
stRotation?: number;
/**
*
*/
bindClock?: boolean;
/**
* [x,y] x y方向重复
*/
repeat?: Array<number>;
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#plottingPointLine'>线</a>
*/
class PolylineGraphic extends GraphicItem {
protected _opt: PolylineGraphicOpt;
protected _type: string;
private _interpolationCallback;
/**
*
* @param option
* @return
* ```
* :
* let polyline = new GV.PolylineGraphic({
* positions:[new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)], //设置坐标
* lineStyle: new GV.ColorStyle({color: '#ffff00'}), //设置颜色
* width: 3, //设置宽度
* clampToGround: true //设置贴地
* });
* viewer.graphicLayer.add(polyline); //添加到场景
* ```
*/
constructor(option: PolylineGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* ```
*
* polyline.positions = [new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)]
* ```
*/
positions: Array<GeoPoint>;
/**
* 线
* ```
*
* polyline.arcType = GV.ArcTypeEnum.Geodesic
* ```
*/
arcType: ArcTypeEnum;
/**
* (线GV.ArcTypeEnum.None时贴地无效)
* ```
*
* polyline.clampToGround = true;
* ```
*/
clampToGround: boolean;
/**
* 线 (单位:像素) (: >0 && <100)
* ```
*
* polyline.width = 10
* ```
*/
width: number;
/**
*
*/
dirty: boolean;
/**
* 线
* 线
* @return
* ```
* :
* polyline.lineStyle = new GV.DynamicStyle({//设置动态样式
* color: '#ffff00', //颜色
* icon: GV.DynamicIconEnum.Attack, //样式图表
* duration:800 //周期
* })
* ```
*/
lineStyle: ColorStyle | ArrowStyle | OutlineStyle | DashStyle | GlowStyle | DynamicStyle | TextureStyle;
color: string;
/**
*
* @param callback
* @return
* ```
*
* polyline.setInterpolationCallback((value)=>{
* return Calculate.getBezier(value) //根据当前点数据value生成贝塞尔点数据
* })
* ```
*/
setInterpolationCallback(callback: any): void;
/**
* ()
* @param value
*/
getInterpolationCallback(value: Array<GeoPoint>): Array<GeoPoint> | Array<Cesium.Cartesian3>;
}
/**
* 线
*/
class PolylineGraphicOpt extends GraphicItemOpt {
/**
* 线
* 线
*/
lineStyle: ColorStyle | ArrowStyle | OutlineStyle | DashStyle | GlowStyle | DynamicStyle | TextureStyle;
/**
*
*/
positions: Array<GeoPoint>;
/**
* 线
*/
arcType?: ArcTypeEnum;
/**
*
*/
clampToGround?: boolean;
/**
* 线
*/
width: number;
/**
*
*/
dirty: boolean;
}
enum ArcTypeEnum {
/**
* 线
*/
Geodesic,
/**
* (线线)
*/
None,
/**
* 线
*/
Rhumb
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#popover'></a>
*/
class PopoverGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: PopoverGraphicOpt;
/**
*
* @param option
* ```
*
* let popoverGraphic = new GV.PopoverGraphic({
* position: new GV.GeoPoint(-75.59777, 40.03883, 100),
* text: "中科星图中科星图中科星图中科星图中科星图中科星图中科星图中科星图",
* shapeType: "pebbles",
* scale: 1.0,// 0.5
* horizontalOrigin: 'left',
* verticalOrigin: 'bottom',
* textTopMargin:'20px',
* textRightMargin:'31px',
* textLeftMargin:'31px'
* });
* ```
*/
constructor(option: PopoverGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getRenderObject(): any;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
updatePopoverCanvas(): void;
/**
*
*/
shapeType: any;
/**
* 线
*/
lineColor: any;
/**
* 线
*/
lineWidth: any;
/**
* 线
*/
lineType: any;
/**
*
*/
text: any;
/**
*
*/
enableFill: any;
/**
*
*/
fillColor: any;
/**
*
*/
labelFont: any;
/**
*
*/
textLeftMargin: any;
/**
*
*/
textRightMargin: any;
/**
*
*/
textTopMargin: any;
/**
*
*/
textBottomMargin: any;
/**
*
*/
textAlign: any;
/**
* red black HTML style
*/
labelFontColor: any;
/**
*
*/
labelFontSize: any;
/**
*
*/
scale: any;
/**
* : 'left' ; 'center' ; 'right' ;
*/
horizontalOrigin: any;
/**
* : 'baseline'线; 'bottom' ; 'center' ; 'top'
*/
verticalOrigin: any;
/**
* [x,y,z]
*/
eyeOffset: any;
/**
* [x,y] x:相对中心点屏幕横向偏移 y:相对中心点屏幕纵向偏移
*/
pixelOffset: any;
/**
*沿
*/
rotation: any;
/**
* 宽度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
width: any;
/**
* 高度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
height: any;
/**
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color: any;
/**
*
*/
sizeInMeters: any;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference: any;
}
class PopoverGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
scale?: number;
/**
* : 'left' ; 'center' ; 'right' ;
*/
horizontalOrigin?: String;
/**
* : 'baseline'线; 'bottom' ; 'center' ; 'top'
*/
verticalOrigin?: String;
/**
* [x,y,z]
*/
eyeOffset?: Array<number>;
/**
* [x,y] x:相对中心点屏幕横向偏移 y:相对中心点屏幕纵向偏移
*/
pixelOffset?: Array<number>;
/**
* 沿
*/
rotation?: number;
/**
* 宽度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
width: number;
/**
* 高度: 默认以像素为单位sizeInMeters参数为true是单位为米; 0
*/
height: number;
/**
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color?: String;
/**
*
*/
sizeInMeters?: Boolean;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
/**
* pebbles pebblesrect roundedrectangle ellipse
*/
shapeType?: String;
/**
* 线
*/
lineColor?: String;
/**
* 线
*/
lineWidth?: String;
/**
* 线 line 线 point dottedLine 线 dottedAndPointLine 线
*/
lineType?: String;
/**
*
*/
enableFill?: boolean;
/**
*
*/
fillColor?: String;
/**
*
*/
text?: String;
/**
* Microsoft YaHei NSimSun KaiTi
*/
labelFont?: String;
/**
* red black HTML style
*/
labelFontColor?: String;
/**
*
*/
labelFontSize?: String;
/**
*
*/
textLeftMargin?: String;
/**
*
*/
textRightMargin?: String;
/**
*
*/
textTopMargin?: String;
/**
*
*/
textBottomMargin?: String;
/**
* center left right
*/
textAlign?: String;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#radar'></a>
*/
class RadarGraphic extends GraphicPositionItem {
/**
*
* @param option
* ```
* :
* let opt = new GV.RadarGraphicOpt();
* opt.position = new GV.GeoPoint(114, 32);
* let obj1 = new GV.RadarGraphic(opt);
* viewer.graphicLayer.add(obj1);
*
* ```
*/
constructor(option: RadarGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @param value
*/
/**
*
* @returns
*/
outerColor: string;
/**
*
* @param value
*/
/**
*
* @returns
*/
outerAlpha: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
innerColor: string;
/**
*
* @param value
*/
/**
*
* @returns
*/
innerAlhpa: number;
/**
* 线
* @param value 线
*/
/**
* 线
* @returns
*/
lineColor: string;
/**
* endAngle - scanAngle - 1
* @param value
*/
/**
*
* @returns
*/
startAngle: number;
/**
* startAngle + scanAngle + 1
* @param value
*/
/**
*
* @returns
*/
endAngle: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
vStartAngle: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
vEndAngle: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
radius: number;
/**
* endAngle - startAngle - 1
* @param value
*/
/**
*
* @returns
*/
scanAngle: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
scanColor: string;
/**
*
* @param value
*/
/**
*
* @returns
*/
scanReserve: boolean;
/**
* /
* @param value
*/
/**
*
* @returns
*/
scanSpeed: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
showScan: boolean;
/**
* 线
* @param value
*/
/**
* 线
* @returns
*/
showLine: boolean;
/**
*
* @param value
*/
/**
*
* @returns
*/
showTriangle: boolean;
readonly fillScan: any;
}
/**
*
*/
class RadarGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
outerColor?: string;
/**
*
*/
outerAlpha?: number;
/**
*
*/
innerColor?: string;
/**
*
*/
innerAlhpa?: number;
/**
*
*/
startAngle?: number;
/**
*
*/
endAngle?: number;
/**
*
*/
vStartAngle?: number;
/**
*
*/
vEndAngle?: number;
/**
*
*/
radius?: number;
/**
*
*/
scanAngle?: number;
/**
*
*/
scanColor?: string;
/**
*
*/
scanReserve?: boolean;
/**
* ,
*/
scanSpeed?: number;
/**
*
*/
showScan?: boolean;
/**
* 线
*/
lineColor?: string;
/**
* 线
*/
showLine?: boolean;
/**
*
*/
showTriangle?: boolean;
/**
*
*/
fillScan?: boolean;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#geometry'></a>
*/
class RectangleGraphic extends GraphicItem {
/**
*
*/
protected _opt: RectangleGraphicOpt;
/**
*
*/
protected _type: string;
/**
*
* @param option
* ```
*
* let rectangleGraphic = new GV.RectangleGraphic({...});
* ```
*/
constructor(option: RectangleGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
coordinates: any;
/**
*
*/
positions: any;
/**
*
*/
height: any;
/**
*
*/
heightReference: any;
/**
*
*/
extrudedHeight: any;
/**
* 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
extrudedHeightReference: any;
/**
*
*/
fill: any;
/**
*
*/
color: any;
image: any;
readonly transparent: Boolean;
/**
*
*/
outline: any;
/**
*
*/
outlineColor: any;
/**
* : 'cast_only' ; 'disabled' ; 'enabled' ; 'receive_only' ;
*/
shadows: any;
movePosition(offsetLon?: number, offsetLat?: number, offsetAlt?: number): void;
}
/**
*
*/
class RectangleGraphicOpt extends GraphicItemOpt {
/**
* [west, south, east, north] west为最西经度 south east为最东经度 north为最北纬度;()
*/
coordinates: Array<number>;
/**
*
*/
positions: Array<GeoPoint>;
/**
* 高度: 默认以像素为单位
*/
height?: number;
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
/**
*
*/
extrudedHeight?: number;
/**
* extrudedHeight的相对参考'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
extrudedHeightReference?: String;
/**
*
*/
fill?: Boolean;
/**
*
*/
color?: String;
/**
*
*/
image?: String;
/**
* image false
*/
transparent?: Boolean;
/**
*
*/
outline?: Boolean;
/**
*
*/
outlineColor?: String;
/**
* : 'cast_only' ; 'disabled' ; 'enabled' ; 'receive_only' ;
*/
shadows?: String;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#radarScan'></a>
*/
class ScanGraphic extends GraphicPositionItem {
protected _opt: ScanGraphicOpt;
/**
*
* @param option
* ```
* :
* let opt = new GV.ScanGraphicOpt();
* opt.scanColor = 'rgba(255.0, 0.0, 0.0, 1)';
* opt.position = new GV.GeoPoint(80, 31.85, 0);
* opt.radius = 1500;
* radarScan = new GV.ScanGraphic(opt);
* viewer.graphicLayer.add(radarScan);
*
* ```
*/
constructor(option: ScanGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @returns
*/
/**
*
* @param value
*/
scanColor: string;
/**
* 线
* @returns
*/
/**
* 线
* @param value
*/
scanLineColor: string;
/**
*
* @returns
*/
/**
*
* @param value
*/
radius: number;
/**
*
* @returns
*/
/**
*
* @param val
*/
speed: number;
/**
* 线
* @returns
*/
/**
* 线
* @param val
*/
lineWidth: number;
readonly clampToGround: true;
}
/**
*
*/
class ScanGraphicOpt extends GraphicPositionItemOpt {
/**扫描板颜色 */
scanColor?: string;
/**扫描波边框线颜色 */
scanLineColor?: string;
/**扫描半径 */
radius?: number;
/**扫描速度 范围 >0&&<=5 */
speed?: number;
/**扫描波边框线宽度 */
lineWidth?: number;
}
class ScreenTextGraphic extends GraphicItem {
protected _opt: ScreenTextGraphicOpt;
constructor(option: ScreenTextGraphicOpt);
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* /
*/
visible: boolean;
/**
*
*/
position: [number, number];
/**
*
*/
width: number;
/**
*
*/
height: number;
/**
*
*/
fontColor: string;
/**
*
*/
outlineColor: string;
/**
*
*/
outlineStyle: string;
/**
*
*/
outlineWidth: number;
/**
*
*/
fontSize: number;
/**
*
*/
fontFamily: string;
/**
*
*/
fontWeight: number;
/**
*
*/
textAlign: string;
/**
* /
*/
isShowBackgroundImg: boolean;
/**
*
*/
backgroundColor: string;
/**
*
*/
backgroundImgUrl: string;
/**
*
*/
backgroundImgSize: string | [number, number];
/**
*
*/
backgroundImgPos: string;
/**
*
*/
backgroundImgRepeat: string;
/**
*
*/
paddingLeft: number;
/**
*
*/
paddingRight: number;
/**
*
*/
paddingTop: number;
/**
*
*/
paddingBottom: number;
/**
*
*/
lineHeight: number;
/**
*
*/
zIndex: number;
/**
*
*/
text: string;
toJson(): {
type: string;
id: any;
name: string;
extendInfo: any;
};
parseJson(option: any): void;
}
class ScreenTextGraphicOpt extends GraphicItemOpt {
position?: [number, number];
width?: number;
height?: number;
backgroundColor?: string;
outlineWidth?: number;
outlineColor?: string;
outlineStyle?: string;
fontSize?: number;
fontColor?: string;
fontFamily?: string;
fontWeight?: number;
textAlign?: string;
isShowBackgroundImg?: boolean;
backgroundImgUrl?: string;
backgroundImgSize?: string | [number, number];
backgroundImgPos?: string;
backgroundImgRepeat?: string;
paddingLeft?: number;
paddingRight?: number;
paddingTop?: number;
paddingBottom?: number;
lineHeight?: number;
zIndex?: number;
text?: string;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#sectorSensor'></a>
*/
class SectorGraphic extends GraphicItem {
protected _opt: SectorGraphicOpt;
protected _type: string;
/**
*
* @param option
* ```
* :
* let sectorGraphicOpt=new GV.SectorGraphicOpt();
* let sector = new GV.SectorGraphic(sectorGraphicOpt);
* viewer.graphicLayer.add(sector);
* ```
*/
constructor(option: SectorGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
positions: Array<GeoPoint>;
/**
*
* @param value
*/
/**
*
* @returns
*/
topPosition: GeoPoint;
/**
*
* @param value
*/
/**
*
* @returns
*/
bottomPosition: GeoPoint;
/**
* ,
* @returns
*/
/**
*
*/
position: GeoPoint;
/**
*
* @param value
*/
/**
*
* @returns
*/
fov: number;
/**
*
* @param value 1-5
*/
/**
*
* @returns
*/
speed: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
evenConeColor: string;
/**
*
* @param value
*/
/**
*
* @returns
*/
oddConeColor: string;
/**
*
* @returns
*/
/**
*
* @param value
*/
rotation: number;
/**
* @ignore
* PolylineCreator使用
*/
getMaxCtrlPosNum(): number;
}
/**
*
*/
class SectorGraphicOpt extends GraphicItemOpt {
/**顶点位置 */
topPosition?: GeoPoint;
/**底点位置 */
bottomPosition?: GeoPoint;
/**
*
*/
fov?: number;
/**
* 1-5
*/
speed?: number;
/**
*
*/
evenConeColor?: string;
/**
*
*/
oddConeColor?: string;
rotation?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#sensor'></a>
*/
class SensorGraphic extends GraphicPositionItem {
protected _opt: SensorGraphicOpt;
/**
*
* @param option
* ```
* :
* let opt = new GV.SensorGraphicOpt();
* opt.color = 'rgba(255,255,255,0.1)';
* opt.position = new GV.GeoPoint(0, 0, 0);
* let sensor = new GV.SensorGraphic(opt);
* viewer.graphicLayer.add(sensor);
*
* ```
*/
constructor(option: SensorGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @param
*/
/**
*
* @returns
*/
radius: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
color: string;
/**
* 线
*/
/**
* 线
* @returns
*/
lineColor: string;
/**
*
* @returns
*/
readonly xHalfAngle: number;
/**
*
* @returns
*/
readonly yHalfAngle: number;
/**
*
* @param value
*/
/**
*
* @returns
*/
scanPlaneColor: any;
/**
*
* @returns
*/
readonly showScanPlane: boolean;
/**
*
* @param value
*/
/**
*
* @returns
*/
scanPlaneRate: any;
readonly clampToGround: true;
}
/**
*
*/
class SensorGraphicOpt extends GraphicPositionItemOpt {
/**半径 */
radius?: number;
/**扫描速率 */
scanPlaneRate?: number;
/**是否显示扫描面 */
showScanPlane?: boolean;
/**水平半角 */
xHalfAngle?: number;
/**垂直半角 */
yHalfAngle?: number;
/**扫描面颜色 */
scanPlaneColor?: string;
/**颜色 */
color?: string;
/**线颜色 */
lineColor?: string;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#geometry'></a>
*/
class SphereGraphic extends GraphicPositionItem {
/**
*
*/
protected _opt: SphereGraphicOpt;
/**
*
* @param option
* ```
*
* let sphereGraphic = new GV.SphereGraphic({...});
* ```
*/
constructor(option: SphereGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
heightReference: any;
/**
*
*/
radius: any;
/**
*
*/
fill: any;
/**
*
*/
color: any;
/**
* 线
*/
outline: any;
/**
* 线
*/
outlineColor: any;
/**
* 线
*/
outlineWidth: any;
/**
*
*/
subdivisions: any;
/**
*
*/
stackPartitions: any;
/**
*
*/
slicePartitions: any;
}
/**
*
*/
class SphereGraphicOpt extends GraphicPositionItemOpt {
/**
* : 'clamp_to_ground' ; 'none' ; 'relative_to_ground' =+
*/
heightReference?: String;
/**
* [x, y, z]
*/
radius?: number;
/**
*
*/
fill?: Boolean;
/**
*
*/
color?: String;
/**
*
*/
outline?: Boolean;
/**
*
*/
outlineColor?: String;
/**
*
*/
outlineWidth?: number;
/**
*
*/
subdivisions?: number;
/**
*
*/
stackPartitions?: number;
/**
*
*/
slicePartitions?: number;
}
/**
*
* SpreadCircleLineGraphic
* SpreadCircleClampGraphic
* SpreadCircleRampGraphic
* SpreadCircleRingGraphic
*/
class SpreadCircleGraphic extends GraphicPositionItem {
constructor(opt: any);
/**
*
*/
color: string;
/**
*
*/
duration: number;
/**
*
*/
radius: number;
}
/**
*
*/
class SpreadCircleGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
color: string;
/**
*
*/
duration: number;
/**
*
* 2D视图时
*/
radius: number;
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#stripeCircle'></a>
*/
class SpreadCircleLineGraphic extends SpreadCircleGraphic {
/**
*
*/
protected _opt: SpreadCircleLineGraphicOpt;
/**
*
* @param option
* ```
* :
* let circleLine = new GV.SpreadCircleLineGraphic({
* color: 'rgba(255.0, 255.0, 0.0, 1)',
* position: new GV.GeoPoint(120.9484503004, 24.0156814236),
* duration: 2,
* radius: 1200
* });
* viewer.graphicLayer.add(circleLine)
* ```
*/
constructor(opt: SpreadCircleGraphicOpt);
/**
*
*/
getType(): string;
/**
*
*/
readonly clampToGround: boolean;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
renderType: SpreadCircleLineEnum;
}
class SpreadCircleLineGraphicOpt extends SpreadCircleGraphicOpt {
/**
*
*/
renderType: SpreadCircleLineEnum;
}
enum SpreadCircleLineEnum {
'Multiple' = 0,
'Single' = 1
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#circleLine'></a>
*/
class SpreadCircleClampGraphic extends SpreadCircleGraphic {
/**
*
*/
protected _type: string;
/**
*
*/
protected _opt: SpreadCircleGraphicOpt;
/**
*
* @param option
* ```
* :
* let circleLine = new GV.SpreadCircleClampGraphic({
* color: 'rgba(255.0, 255.0, 0.0, 1)',
* position: new GV.GeoPoint(120.9484503004, 24.0156814236),
* duration: 2,
* radius: 1200
* });
* viewer.graphicLayer.add(circleLine)
* ```
*/
constructor(opt: SpreadCircleGraphicOpt);
/**
*
*/
getType(): string;
/**
*
*/
readonly clampToGround: boolean;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#rampCircle'></a>
*/
class SpreadCircleRampGraphic extends SpreadCircleGraphic {
/**
*
*/
protected _type: string;
/**
*
*/
protected _opt: SpreadCircleRampGraphicOpt;
/**
*
* @param option
* ```
* :
* let circleLine = new GV.SpreadCircleRampGraphic({
* color: 'rgba(255.0, 255.0, 0.0, 1)',
* position: new GV.GeoPoint(120.9484503004, 24.0156814236),
* duration: 2,
* radius: 1200
* });
* viewer.graphicLayer.add(circleLine)
* ```
*/
constructor(opt: SpreadCircleRampGraphicOpt);
/**
*
*/
getType(): string;
/**
*
*/
readonly clampToGround: boolean;
/**
* ()
*/
static readonly type: string;
/**
* 线
*/
lineColor: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
}
class SpreadCircleRampGraphicOpt extends SpreadCircleGraphicOpt {
/**
* 线
*/
lineColor: string;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#spreadCircle'></a>
*/
class SpreadCircleRingGraphic extends SpreadCircleGraphic {
/**
*
*/
protected _opt: SpreadCircleRingGraphicOpt;
/**
*
* @param option
* ```
* :
* let circleLine = new GV.SpreadCircleRingGraphic({
* color: 'rgba(252, 0, 32)',
* position: new GV.GeoPoint(120.9484503004, 24.0156814236),
* height: 10,
* radius: 220,
* count: 1,
* speed: 10.0
* });
* viewer.graphicLayer.add(circleLine)
* ```
*/
constructor(opt: SpreadCircleRingGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
height: number;
/**
*
*/
count: number;
/**
*
*/
speed: number;
/**
*
*/
renderType: SpreadCircleRingEnum;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
}
class SpreadCircleRingGraphicOpt extends SpreadCircleGraphicOpt {
/**
*
*/
renderType: SpreadCircleRingEnum;
/**
*
*/
height: number;
/**
*
*/
count: number;
/**
*
*/
speed: number;
}
enum SpreadCircleRingEnum {
'Solid' = 0,
'Ramp' = 1,
'Strip' = 2
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#circleScan'></a>
*/
class SpreadGraphic extends GraphicPositionItem {
protected _opt: SpreadGraphicOpt;
/**
*
* @param option
* ```
* :
* let opt = new GV.SpreadGraphicOpt();
* opt.scanColor = 'rgba(255.0, 0.0, 0.0, 1)';
* opt.position = new GV.GeoPoint(80, 31.85, 0);
* opt.radius = 1500;
* circleScan = new GV.SpreadGraphic(opt);
* viewer.graphicLayer.add(circleScan);
*
* ```
*/
constructor(option: SpreadGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
readonly clampToGround: boolean;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @returns
*/
/**
*
* @param value
*/
spreadColor: string;
/**
*
* @returns
*/
/**
*
* @param value
*/
radius: number;
/**
*
* @returns
*/
/**
*
* @param value 1-10
*/
speed: number;
}
/**
*
*/
class SpreadGraphicOpt extends GraphicPositionItemOpt {
/**扫描颜色 */
spreadColor?: string;
/**扩散半径 */
radius?: number;
/**扩散速度 范围 1-10 */
speed?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#efficientTriangles'></a>
*/
class TriangleMeshGraphic extends GraphicItem {
protected _opt: TriangleMeshGraphicOpt;
protected _type: string;
/**
*
* @param option
* ```
* let urlArr = ['test10.json', 'test15.json'];
* let draw = [];
* for (let i = 0; i < urlArr.length; i++) {
* fetch('../data/radar/' + urlArr[i])
* .then(function (response) {
* return response.json();
* })
* .then(data => {
* let opt = new GV.TriangleMeshGraphicOpt();
* opt.color = '#00CED1';
* opt.dataSource = { points: data.points, indices: data.indices };
* let TMesh = new GV.TriangleMeshGraphic(opt);
* let obj = viewer.graphicLayer.add(TMesh)
* draw.push(obj);
* });
* }
* ```
*/
constructor(option: TriangleMeshGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* points [...] url
*
* points = [102,33,5000,116,39,54411]
*/
dataSource: any;
/**
*
* '#00CED1'
* ```
*
* Tmesh.color = '#fff'
* ```
*/
color: any;
}
/**
*
*/
class TriangleMeshGraphicOpt extends GraphicItemOpt {
/**
*
* dataSource = {
* points: [102,33,5000,116,39,54411...],
* indices:[0,2,3,5...]
* }
* points [...]
* indices
*/
dataSource: {
points: Array<number>;
indices: Array<number>;
};
/**
*
* '#00CED1'
*/
color?: string;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#truncatedCone'></a>
*/
class TruncatedConeGraphic extends GraphicPositionItem {
protected _opt: TruncatedConeGraphicOpt;
/**
*
* @param option
* ```
* :
* let opt = new GV.TruncatedConeGraphicOpt();
* opt.position = new GV.GeoPoint(80, 31.85, 0);
* opt.color = 'rgba(72,155,176,0.8)';
* truncatedCone = new GV.TruncatedConeGraphic(opt);
* viewer.graphicLayer.add(truncatedCone);
*
* ```
*/
constructor(option: TruncatedConeGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
color: string;
/**
*
*/
innerRadius: number;
/**
*
*/
outerRadius: number;
/**
*
*/
innerTopRadius: number;
/**
*
*/
innerBottomRadius: number;
/**
*
*/
innerHeight: number;
/**
*
*/
outerTopRadius: number;
/**
*
*/
outerBottomRadius: number;
/**
*
*/
outerHeight: number;
}
class TruncatedConeGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
color: string;
/**
*
*/
innerRadius: number;
/**
*
*/
outerRadius: number;
/**
*
*/
innerTopRadius: number;
/**
*
*/
innerBottomRadius: number;
/**
*
*/
innerHeight: number;
/**
*
*/
outerTopRadius: number;
/**
*
*/
outerBottomRadius: number;
/**
*
*/
outerHeight: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#truncatedConeParticle'></a>
*/
class TruncatedConeParticleGraphic extends GraphicPositionItem {
protected _opt: TruncatedConeParticleGraphicOpt;
/**
*
* @param option
* ```
* :
* let opt = new GV.TruncatedConeParticleGraphicOpt();
* opt.position = new GV.GeoPoint(80, 31.85, 0);
* opt.color = 'rgba(72,155,176,0.8)';
*
* truncatedCone = new GV.TruncatedConeParticleGraphic(opt);
* viewer.graphicLayer.add(truncatedCone);
*
* ```
*/
constructor(option: TruncatedConeParticleGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
color: string;
/**
*
*/
radiusArray: Array<number>;
/**
*
*/
deltaHeight: number;
/**
*
*/
topRadius: number;
/**
*
*/
bottomRadius: number;
/**
*
*/
height: number;
}
class TruncatedConeParticleGraphicOpt extends GraphicPositionItemOpt {
/**
*
*/
color: string;
/**
*
*/
radiusArray: Array<number>;
/**
*
*/
deltaHeight: number;
/**
*
*/
topRadius: number;
/**
*
*/
bottomRadius: number;
/**
*
*/
height: number;
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#geometry'></a>
*/
class VolumePolylineGraphic extends GraphicItem {
/**
*
*/
protected _opt: VolumePolylineGraphicOpt;
/**
*
*/
protected _type: string;
/**
*
* @param option
* ```
*
* let volumePolylineGraphic = new GV.VolumePolylineGraphic({...});
* ```
*/
constructor(option: VolumePolylineGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
positions: any;
/**
*
*/
shape: any;
/**
*
*/
cornerType: any;
/**
*
*/
fill: any;
/**
*
*/
color: any;
/**
*
*/
outline: any;
outlineColor: any;
outlineWidth: any;
}
/**
*
*/
class VolumePolylineGraphicOpt extends GraphicItemOpt {
/**
* lon为经度 lat alt为高度
* ```
*
* GV.GeoPoint.unpackArray([
* [-80.0, 34.0, 0.0],
* [-80.0, 40.0, 100000.0],
* [-84.0, 40.0, 0.0]
* ])
* ```
*/
positions: Array<GeoPoint>;
/**
*
* ```
*
* GV.GeoPoint.unpackArray([
* [-50000, -50000],
* [50000, -50000],
* [50000, 50000],
* [-50000, 50000]
* ])
* ```
*/
shape: Array<GeoPoint>;
/**
* : 'beveled' 'mitered' 'rounded'
*/
cornerType?: String;
/**
* true or false
*/
fill?: Boolean;
/**
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color?: String;
/**
* true or false
*/
outline?: Boolean;
/**
* 轮廓颜色: 参考颜色示例'#ff0000''rgba(255,0,0,1)'
*/
outlineColor?: String;
/**
* 线
*/
outlineWidth?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#geometry'></a>
*/
class WallGraphic extends GraphicItem {
/**
*
*/
protected _opt: WallGraphicOpt;
/**
*
*/
protected _type: string;
/**
*
* @param option
* ```
*
* let wallGraphic = new GV.WallGraphic({...});
* ```
*/
constructor(option: WallGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
*/
positions: any;
/**
*
*/
maximumHeights: any;
/**
*
*/
minimumHeights: any;
/**
*
*/
fill: any;
/**
*
*/
color: any;
/**
*
*/
outline: any;
outlineColor: any;
outlineWidth: any;
}
/**
*
*/
class WallGraphicOpt extends GraphicItemOpt {
/**
* lon为经度 lat alt为高度
* ```
*
* GV.GeoPoint.unpackArray([
* [-115.0, 34.0],
* [-112.5, 34.0],
* [-110.0, 34.0],
* [-107.5, 34.0],
* [-105.0, 34.0],
* [-102.5, 34.0],
* [-100.0, 34.0],
* [-97.5, 34.0],
* [-95.0, 34.0],
* [-92.5, 34.0],
* [-90.0, 34.0]
* ])
* ```
*/
positions: Array<GeoPoint>;
/**
* .[100000, 200000, 100000, 200000, 100000, 200000 ...]
*/
maximumHeights: Array<number>;
/**
* .[0, 100000, 0, 100000, 0, 100000, 0,...]
*/
minimumHeights: Array<number>;
/**
* true or false
*/
fill?: Boolean;
/**
* 颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
color?: String;
/**
* true or false
*/
outline?: Boolean;
/**
* 轮廓颜色: 参考颜色示例'#ff0000''rgba(1,0,0,1)'
*/
outlineColor?: String;
/**
* 线
*/
outlineWidth?: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#waterPrimitive' target="_blank"></a>
*/
class WaterFaceGraphic extends GraphicItem {
protected _opt: WaterFaceGraphicOpt;
protected _type: string;
/**
*
* @param {WaterFaceGraphicOpt} options
* ```
* //示例
* const polygon=new Cesium.PolygonGeometry(
* Cesium.Cartesian3.fromDegreesArray([100,30,110,30,110,40,100,40])
* )
* const waterOpt=new GV.WaterFaceGraphicOpt();
* waterOpt.waterPolygon=polygon;
* waterOpt.waterColor=Cesium.Color.BLUE;
* const water = new GV.WaterFaceGraphic(opt)
viewer.graphicLayer.add(water);
* ```
*/
constructor(options: WaterFaceGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* item的基类方法,
* add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @example
* water.waterColor=Cesium.Color.BLUE;
*/
waterColor: Cesium.Color;
/**
*
*/
waveWidth: Number;
/**
*
*/
flowDirection: Number;
/**
*
*/
flowSpeed: Number;
readonly normalTexture: String;
/**
*
* @readonly
*/
readonly waterPolygon: Cesium.PolygonGeometry;
}
class WaterFaceGraphicOpt extends GraphicItemOpt {
/**
*
*/
waterColor: Cesium.Color;
/**
*
*/
waveWidth: Number;
/**
*
*/
flowDirection: Number;
/**
*
*/
flowSpeed: Number;
/**
* 线
*/
normalTexture: String;
/**
*
*/
waterPolygon: Cesium.PolygonGeometry;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#water'></a>
*/
class WaterGraphic extends GraphicItem {
protected _opt: WaterGraphicOpt;
protected _type: string;
/**
*
* @param option
* ```
* :
* var position = [0, 0,0, 40.0,40, 40.0,40, 0];
* var holes = [[5, 5, 6, 5, 6, 6, 5, 6],[15, 15, 15, 25, 25, 25, 25, 15]];
* let waterOpt = new GV.WaterGraphicOpt();
* waterOpt.pointsList = position;
* waterOpt.holes = holes;
* let water = new GV.WaterGraphic(waterOpt);
* viewer.graphicLayer.add(water);
* ```
*/
constructor(option: WaterGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @returns
*/
/**
*
* @param value
*/
frequency: number;
/**
*
* @returns
*/
/**
*
* @param val '#177BD9''rgba(100, 0.3, 0.6,1)'
*/
baseWaterColor: string;
/**
*
* @returns
*/
/**
*
* @param val
*/
animationSpeed: number;
/**
*
* @returns
*/
/**
*
* @param val
*/
amplitude: number;
/**
*
* @returns
*/
/**
*
* @param val
*/
specularIntensity: number;
/**
*
* @returns
*/
readonly holes: number[][];
/**
*
* @returns
*/
readonly pointsList: number[];
readonly mode: string;
}
/**
*
*/
class WaterGraphicOpt extends GraphicItemOpt {
/**
*
*/
pointsList: Array<number>;
/**
*
*/
holes?: Array<Array<number>>;
/**
*
*/
frequency?: number;
/**
*
*/
animationSpeed?: number;
/**
*
*/
amplitude?: number;
/**
*
*/
specularIntensity?: number;
/**
*
*/
baseWaterColor?: string;
/**
*
*/
mode?: string;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#weatherPack'></a>
*/
class WeatherGraphic extends GraphicItem {
protected _opt: WeatherGraphicOpt;
/**
*
* @param option
* ```
* :
* let weatherGraphicOpt = new GV.WeatherGraphicOpt();
* weatherGraphicOpt.position = new GV.GeoPoint(110.20, 34.55, 3000);
* weatherGraphicOpt.range = 20000;
* weatherGraphicOpt.weatherType = 'rain';
* var weatherGraphic = new GV.WeatherGraphic(weatherGraphicOpt);
* viewer.graphicLayer.add(weatherGraphic);
*
* ```
*/
constructor(option: WeatherGraphicOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
init(father: GraphicGroup): void;
/**
*
* @returns
*/
/**
*
* @param value
*/
weatherType: string;
/**
*
* @returns
*/
/**
*
* @param value
*/
position: GeoPoint;
/**
*
* @returns
*/
/**
*
* @param value
*/
range: number;
}
/**
*
*/
class WeatherGraphicOpt extends GraphicItemOpt {
/**天气类型 rain 或 snow*/
weatherType: string;
/**位置 */
position: GeoPoint;
/**影响范围 */
range: number;
}
/// <reference path="../../../../src/Types/cesium.d.ts" />
/**
* @类别 </br>
* @描述
*/
class GraphicLayer extends Event {
_viewer: Cesium.Viewer;
private _dataRoot;
private _ignoreRoot;
private _renderRoot;
private _creatorManager;
private _editorManager;
private _pipelineManager;
constructor(viewer: Cesium.Viewer);
private _initCreatorManager;
/**
* @description:
* @param {number} x 沿x轴偏移的像素值或百分比
* @param {number} y 沿y轴偏移的像素值或百分比
* @return {*}
*/
setViewOffset(x: number | string, y: number | string): void;
/**
* 使
*/
getRenderRoot(): {
entityRoot: Cesium.EntityCollection;
primitiveRoot: Cesium.PrimitiveCollection;
postProcessStages: any;
billboardCollection: Cesium.BillboardCollection;
labelCollection: Cesium.LabelCollection;
htmlItemCollection: HtmlItemCollection;
};
editOpen(): void;
editClose(): void;
readonly isEditting: boolean;
/**
*
* @param itemOpt
* @param group
*/
create(itemOpt: any, group?: GraphicGroup, finishCallback?: any): GraphicItem;
/**
* /
* @param vis
*/
setEditorLabelVisible(vis: boolean): void;
/**
* /
* @param b true:
*/
setEditorLabelFormat(b: boolean): void;
/**
*
*/
getEditorManager(): EditorManager;
/**
*
*/
setEditItem(item: GraphicItem): void;
/**
*
*/
getEditItem(): GraphicItem;
/**
* dom
*/
setEditorElement(element: Element): void;
/**
*
*/
onEditItemRealTimeChange(fun: any): void;
/**
*
*/
offEditItemRealTimeChange(): void;
/**
*
*/
onEditItemChange(fun: any): Function;
/**
*
*/
offEditItemChange(fun: any): void;
/**
*
*/
onEditorClick(fun: any): void;
/**
*
*/
offEditorClick(): void;
/**
*
*/
getRoot(): GraphicGroup;
/**
*
*/
getIgnoreRoot(): GraphicGroup;
/**
*
*/
getPipelineManager(): PipelineManager;
/**
*
* @param node
* @returns
* ```
*
* //添加绘制数据对象
* let obj = new GV.CylinderDynamicGraphic({
* topPosition: new GV.GeoPoint(0,0,200000),
* bottomPosition: new GV.GeoPoint(0,0,0)
* })
* viewer.graphicLayer.add(obj);
*
* //添加组对象并在组对象中添加标绘
* let group = new GV.GraphicGroup();
* viewer.graphicLayer.add(group);
*
* let polyline = new GV.PolylineGraphic({
* positions:[new GV.GeoPoint(0,0,200000), new GV.GeoPoint(100,0,200000)],
* lineStyle: new GV.ColorStyle({color: '#ffff00'}),
* width: 3,
* });
* group.add(polyline);
* ```
*/
add(node: GraphicGroup | GraphicItem): GraphicGroup | GraphicItem;
addByJson(json: any): any;
/**
* json数据
*/
toJson(): object;
/**
* json数据
*/
fromJson(json: object): GraphicGroup;
/**
*
* @param node
* @return
* ```
*
* viewer.graphicLayer.remove(node)
* ```
*/
remove(node: GraphicGroup | GraphicItem): GraphicGroup | GraphicItem;
/**
*
*/
clear(): void;
/**
* ID获取对象
* @param id
* @return
*/
getById(id: string): any;
/**
* ID获取对象
* @param id
* @return
*/
getIgnoreById(id: string): any;
/**
*
*
* @param name
* @return
*/
getNodeByName(name: string): (GraphicItem | GraphicGroup)[];
private _pickObjGetId;
/**
* plot对象
* @param {Function} callback
*/
pickRect(x: number, y: number, width: number, height: number): Array<GraphicItem>;
/**
*
* @param x
* @param y
*/
pickByCoordinate2(x: number, y: number): Array<GraphicItem>;
/**
*
* @param x x
* @param y y
* @return
*/
pickByCoordinate(x: number, y: number): GraphicItem;
/**
*
* @param x x
* @param y y
* @return
*/
pickIgnoreByCoordinate(x: number, y: number): GraphicItem;
/**
*
*/
/**
*
* @param x
* @param y
* @param type ''|Ignore对数据根节点求交
*/
private _pickByCoordinate2;
private _pickByCoordinate;
private _pickSpecialGraphic;
/**
* ()
* @param positions
* @return
* @see <a href='../../../examples/gallery/editor.html#getItemsInPolygon'></a>
*/
getItemsInPolygon(positions: Array<GeoPoint>): Array<GraphicItem>;
}
/// <reference path="../../../../../src/Types/cesium.d.ts" />
class AttractPointRender extends RenderPositionObject {
private _appearance1;
private _appearance2;
private _appearance3;
private _appearance4;
private _primitive1;
private _primitive2;
private _primitive3;
private _primitive4;
private _buildGeometry;
private partTwoScale;
private offset;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
/**
*
*/
protected dataUpdate(): void;
readonly renderType: RenderTypeEnum;
private createPartOneImage;
private getPartOneMs;
private createPartTwoImage;
private getPartTwoMs;
private getPartThreeMs;
private getPartFourMs;
getModelMatrix(): Cesium.Matrix4;
protected getOffsetModelMatrix(): Cesium.Matrix4;
private createAppearance;
private createPrimitive;
update(): void;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class BindedCylinder extends RenderPositionObject {
private _appearance;
private _circleData;
private _matrix;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
readonly renderType: RenderTypeEnum;
update(): void;
/**
*
*/
updateAttribute(attrName: any): void;
/**计算单位圆周坐标值 */
private calculateCircleData;
/**
* Appearance
*/
private createAppearance;
/**
*
* @param height
* @param angle
*/
private createGeometry;
/**
* vao需要数据
* @param topPosArr
* @param bottomPosArr
* @param slice
*/
private createGeometeryAttribute;
/**
* Primitive
* @param postionsTemp
* @param stsTemp
*/
private createPrimitive;
/**
*
*/
private createModelMatrix;
}
class BlastRender extends RenderPositionObject {
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
computeModelMatrix(position: any): any;
computeEmitterModelMatrix(): Cesium.Matrix4;
/**
*
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class Bubble extends RenderObject {
_container: HTMLDivElement;
_rootNode: HTMLDivElement;
_parentNode: HTMLDivElement;
_panelNode: HTMLDivElement;
_lineNode: HTMLDivElement;
_renderVisible: boolean;
_anchorOffset: {
x: number;
y: number;
};
_panelOffset: {
x: number;
y: number;
};
_diagonalPanelOffset: {
x: number;
y: number;
};
private _isMouseDown;
private _downX;
private _downY;
private _bottomX;
private _bottomY;
private _bubbleEvent;
private _fnDown;
private _fnUp;
private _fnMove;
private _fnStart;
private _fnTMove;
private _fnEnd;
/**
*
*/
init(): void;
/**
*
*/
clear(): void;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
/**
*
*/
update(): void;
/**
* ()
* @param point
* @param viewer
*/
pointIsVisible(point: GeoPoint, viewer: Cesium.Viewer): boolean;
/**
*
*/
private _preRender;
/**
*
* @param offsetX
* @param offsetY
*/
private _updateDiv;
private _getDiagonalPanelOffset;
/**
* 线
* @param object
* @param bindNode
* @returns
*/
private _updateLinePosition;
/**
* moveDiv的位置
* @param x x坐标
* @param y y坐标
*/
_updatePanelPosition(x: any, y: any): void;
/**
*
* @param visible
*/
private _showDiv;
/**
* dom元素
*/
private _initDom;
/**
* DOM方法
*/
private _createDom;
/**
*
* @param val
*/
private _getDivOffsetOfBody;
/**
* DOM
*/
private _getDom;
private _mouseDown;
private _mouseMove;
private _mouseUp;
private _touchStart;
private _touchMove;
private _touchEnd;
/**
* DOM元素
* @param _element
*/
private _removeElement;
/**
*
*/
private _bindEvent;
/**
*
*/
private _removeEvent;
}
/**
*
*/
class CesiumBillboard extends RenderPositionObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
private _dealResProps;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumCylinder extends RenderPositionObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
private _getOrientation;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumEllipse extends RenderPositionObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumEllipsoid extends RenderPositionObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumLabel extends RenderPositionObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumLabelBillboard extends RenderObject {
readonly renderType: RenderTypeEnum;
private _root;
/**
*
*/
init(): void;
/**
*
*/
private createCanvas;
/**
*
* @param move
*/
updateCanvas(move: any): HTMLCanvasElement;
/**
*
* @param ctx
* @param content
* @param drawX
* @param drawY
* @param textOpt
*/
textPrewrap(ctx: any, content: any, drawX: any, drawY: any, textOpt: any): void;
/**
*
*/
clear(): void;
/**
*
*/
update(): void;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumLabelRect extends RenderPositionObject {
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
private updateCanvas;
/**
*
*/
update(): void;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumModel extends RenderPositionObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
private getOrientation;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
private _dealResProps;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumOblique extends RenderObject {
/**
* @ignore
*/
private _originTransform;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
clear(): void;
/**
* @ignore
*/
private updateOffset;
/**
* @ignore
*/
private updateRotate;
}
class CesiumPoint extends RenderPositionObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
update(): void;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
*/
updateAttribute(attrName: any): void;
}
class CesiumPolygon extends RenderObject {
_positions: any[];
private _originProps;
private _resProps;
private _synchronizer;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
update(): void;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
*/
updateAttribute(attrName: any): void;
getRenderPositions(): any[];
getRenderHoles(): any[];
}
class CesiumPolyline extends RenderObject {
_positions: any[];
private _originProps;
private _resProps;
private _cameraChange;
private _length;
readonly renderType: RenderTypeEnum;
static _onSceneModeChange: any;
static _parabolaLines: any[];
/**
*
*/
init(): void;
private addCameraListener;
private removeCameraListener;
/**
*
*/
private updateTextureTimes;
private calculateLength;
update(): void;
getRenderPositions(): any[];
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
/**
*
*/
class CesiumPopover extends RenderPositionObject {
readonly renderType: RenderTypeEnum;
private billboardCanvas;
private flag;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
updateCanvas(): void;
private updateCanvasCallBack;
/**
* html标签
* @param shapeType
* @param text
*/
private createHTMLElement;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumRectangle extends RenderObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
private getCoordinates;
calcCoordinates(data: any): Cesium.Rectangle;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumSphere extends RenderPositionObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumVolumePolyline extends RenderObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
starPositions(arms: any, rOuter: any, rInner: any): any[];
/**
*
*/
init(): void;
getShape(value: any): any[];
private getCornerType;
/**
*
*/
update(): void;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
*
*/
class CesiumWall extends RenderObject {
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
class CircularRender extends RenderPositionObject {
private _appearance;
readonly renderType: RenderTypeEnum;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
update(): void;
/**
*
*/
updateAttribute(attrName: any): void;
/**
*
*/
private createMaterial;
/**
*
*/
private createPrimitive;
}
/**
*
*/
class CustomLabelRender extends RenderPositionObject {
private _originProps;
private _resProps;
private pinBuilder;
private image;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
update(): void;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
private _dealResProps;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class CylinderSensor extends RenderObject {
private _circleData;
private _currentOffset;
private _distance;
private _geometry;
private _appearance;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
listenerFun: () => void;
private calculateRepeat;
update(): void;
/**
*
*/
updateAttribute(attrName: any): void;
/**计算单位圆周坐标值 */
private calculateCircleData;
/**
*
*/
private createVertex;
/**
* attribute
* @param topPosArr
* @param bottomPosArr
*/
private createGeometeryAttribute;
/**
*
* @param postionsTemp
* @param stsTemp
*/
private createGrometry;
private getTopPosition;
private getBottomPosition;
/**
*
*/
private createMaterial;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
private createGeometryMatrix;
clear(): void;
}
/**
*
*/
class DashBoardEffect extends RenderPositionObject {
private polygonAppearance;
private polygonGeometry;
private polygonPrimitive;
private angle;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
private createGeometry;
/**
*
*/
private createAppearence;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
private getMS;
private createGeometryMatrix;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class DynamicRippleEffect extends RenderPositionObject {
dataOptions: any;
private _originProps;
private _resProps;
readonly renderType: RenderTypeEnum;
/**
*
*/
/**
*
*/
init(): void;
private _dealResProps;
/**
*
*
*/
updateAttributeForEditing(): void;
private _updateAllProp;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class FireRender extends RenderPositionObject {
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
getSrcByType(): string;
computeModelMatrix(position: any): any;
computeEmitterModelMatrix(): Cesium.Matrix4;
/**
*
*/
updateAttribute(attrName: any): void;
}
class Flag extends RenderObject {
_state: string;
_canvasInfo: {
canvas: Element;
canvasWidth: number;
canvasHeight: number;
offsetAnchor: [number, number];
offsetInflection: [number, number];
flagpoleLeftTop: [number, number];
flagpoleRightTop: [number, number];
flagpoleLeftBottom: [number, number];
flagpoleRightBottom: [number, number];
};
_root: any;
readonly renderType: RenderTypeEnum;
getCanvasInfo(): {
canvas: Element;
canvasWidth: number;
canvasHeight: number;
offsetAnchor: [number, number];
offsetInflection: [number, number];
flagpoleLeftTop: [number, number];
flagpoleRightTop: [number, number];
flagpoleLeftBottom: [number, number];
flagpoleRightBottom: [number, number];
};
private createCanvas;
private _createCanvas;
private _calculatedLabelSize;
private _calculatedcanvasCoordinates;
/**
*
*/
init(): void;
update(): void;
updateCanvas(): void;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class FlowWallRender extends RenderObject {
private appearance;
private speed;
readonly renderType: RenderTypeEnum;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
/**
*
*/
private createMaterial;
private getSource;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class GradientSector extends RenderObject {
private _geometry;
private _appearance;
private _radius;
private _sliceUnit;
readonly renderType: RenderTypeEnum;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
update(): void;
/**
*
*/
updateAttribute(attrName: any): void;
/**
* attribute
*/
private createGeometeryAttribute;
/**
*
* @param postionsTemp
* @param stsTemp
*/
private createGrometry;
/**
*
*/
private createMaterial;
/**
*
*/
private getMS;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
private createGeometryMatrix;
clear(): void;
}
class HtmlElementDrag {
private dragElement;
private container;
private dragX;
private dragY;
private mouseDownX;
private mouseDownY;
private isMouseDown;
private _mouseDownCallback;
private _mouseMoveCallback;
private _mouseUpCallback;
constructor();
onMouseDown(e: MouseEvent, dragElement: HTMLElement, container: HTMLElement): void;
mouseDownCallback: (e: MouseEvent) => void;
mouseMoveCallback: (e: MouseEvent, dragX: number, dragY: number) => void;
mouseUpCallback: (e: MouseEvent) => void;
onMouseMove(e: any): void;
onMouseUp(e: any): void;
static getPosition(element: HTMLElement): [number, number];
static getElementSize(element: HTMLElement): [number, number];
}
class HtmlItem {
protected _id: string;
protected _name: string;
protected _element: HTMLElement;
protected _container: HTMLElement;
constructor(container: HTMLElement, element?: HTMLElement | HtmlItemOpt);
getType(): string;
static readonly type: string;
id: string;
name: string;
element: HTMLElement;
protected initElement(elementOpt?: HTMLElement | HtmlItemOpt): void;
}
class HtmlItemOpt {
type: string;
name?: string;
width?: number;
height?: number;
}
class HtmlItemCollection {
private _id;
private _name;
private _htmlCollection;
private _htmlContainer;
private _container;
private _viewer;
constructor(viewer: GeoCanvas | Cesium.Viewer);
readonly id: string;
readonly values: HtmlItem[];
name: string;
readonly container: HTMLElement;
/**
*
*/
init(): void;
/**
*
*/
add(item: any): HtmlItem;
/**
*
*/
remove(htmlItem: HtmlItem): void;
/**
*
*/
removeAll(): void;
/**
* id删除
*/
removeById(id: string): void;
/**
* id获取对象
*/
getById(id: string): HtmlItem;
/**
*
*/
contains(htmlItem: any): boolean;
private insertCssSheet;
}
class ScreenTextItem extends HtmlItem {
private _childElement;
private _dragElement;
private _childElementMargin;
private _isEditting;
private _parentContainer;
private _onMouseDown;
private _onMouseChangeSize;
private _onMouseChangePos;
private _onTextChange;
constructor(container: HTMLElement, element?: HTMLElement | ScreenTextItemOpt);
getType(): string;
static readonly type: string;
readonly isEditting: boolean;
childElement: HTMLElement;
readonly text: string;
protected initElement(elementOpt?: HTMLElement | ScreenTextItemOpt): void;
setTop(value: number): void;
setLeft(value: number): void;
setWidth(value: number): void;
setHeight(value: number): void;
setMargin(value: number): void;
setProperty(propertyName: any, value: any): void;
setSelectState(isOpen: any): void;
onMouseDown: (e?: MouseEvent) => void;
onMouseChangeSize: (e: MouseEvent, dragX: number, dragY: number) => void;
onMouseChangePos: (e: MouseEvent, dragX: number, dragY: number) => void;
onTextChange: (e: KeyboardEvent, content: string) => void;
openEdit(): void;
closeEdit(): void;
private _initDragElement;
}
class ScreenTextItemOpt extends HtmlItemOpt {
type: string;
name?: string;
left?: number;
top?: number;
width?: number;
height?: number;
color?: string;
borderColor?: string;
borderStyle?: string;
borderWidth?: number;
backgroundColor?: string;
fontSize?: number;
fontFamily?: string;
fontWeight?: number;
textAlign?: string;
backgroundImage?: string;
backgroundSize?: string;
backgroundPosition?: string;
paddingLeft?: number;
paddingRight?: number;
paddingTop?: number;
paddingBottom?: number;
lineHeight?: number;
zIndex?: number;
text?: string;
position: string;
display: string;
backgroundRepeat?: string;
}
class Icon {
protected _position: Cesium.Cartesian3;
protected _radius: Number;
protected _numberOfLines: Number;
protected _color: any;
protected _duration: Number;
protected _image: any;
protected entity: any;
protected viewer: any;
protected options: any;
constructor(options?: {});
color: any;
position: Cesium.Cartesian3;
radius: Number;
numberOfLines: Number;
duration: Number;
image: any;
updateMaterial(type: any, value: any): void;
createEntity(): void;
addTo(viewer: any): void;
exists(): boolean;
remove(): void;
zoomTo(): void;
}
class Icon2 extends Icon {
constructor(options?: {});
createEntity(): Cesium.Entity;
}
class CircleIconRender extends CircleRender {
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
protected getMaterialFS(): string;
/**
*
*/
protected getMaterial(): Cesium.Material;
}
class CircleRender extends RenderPositionObject {
private _buildGeometry;
private _time;
protected _appearance: Cesium.Appearance;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
* @readonly
* @type {RenderTypeEnum}
*/
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
protected dataUpdate(): void;
/**
*
*/
protected getMaterialFS(): string;
/**
*
*/
protected getMaterial(): any;
/**
* Appearence
*/
protected createAppearence(): void;
private getFS;
private getVS;
protected getMatrix(): Cesium.Matrix4;
protected createPolygonGeometry(): any;
/**
* primitive
*/
protected createPrimitive(): void;
/**
*
*/
updateAttribute(attrName: any): void;
}
class IconMaterialProperty {
protected _image: any;
protected _duration: any;
protected _color: any;
protected _numberOfLines: Number;
definitionChanged: any;
protected _time: any;
constructor(options?: {});
image: any;
duration: any;
numberOfLines: Number;
color: any;
isConstant(): Boolean;
translucent(): boolean;
equals(other: any): boolean;
getValue(time: any, result?: {}): {};
}
class Icon6 extends Icon {
private _gradient;
private _centerColor;
constructor(options?: {});
gradient: any;
centerColor: any;
/**
* @override
*/
radius: number;
createEntity(): Cesium.Entity;
}
class WarnIconRender extends CircleRender {
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
protected getMaterialFS(): string;
/**
*
*/
protected getMaterial(): Cesium.Material;
/**
*
*/
updateAttribute(attrName: any): void;
}
class Icon8 extends Icon {
private _gradient;
constructor(options?: {});
gradient: any;
createEntity(): Cesium.Entity;
}
class WaveIconRender extends CircleRender {
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
protected getMaterialFS(): string;
/**
*
*/
protected getMaterial(): Cesium.Material;
/**
*
*/
updateAttribute(attrName: any): void;
}
class IconRender extends RenderPositionObject {
readonly renderType: RenderTypeEnum;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
init(): void;
update(): void;
updateAttribute(attrName: any): void;
clear(): void;
}
class JBLineRender extends RenderObject {
/**数据源 */
result: any[];
/**线 */
linePrimitive: Cesium.Primitive;
/**填充网格体 */
fillPrimitive: Cesium.Primitive;
/**拉高网格体 */
supplementPrimitive: Cesium.Primitive;
/**线的材质 */
lineAppearance: Cesium.PolylineMaterialAppearance;
/**填充网格体材质 */
fillAppearance: Cesium.Appearance;
/**拉高网格体材质 */
supplementAppearance: Cesium.Appearance;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
* JB线
*/
private create;
/**
*
* @param arr
*/
private unique;
/**
*
*/
private addHeight;
/**
* 线
*/
private createLine;
/**
*
*/
private createFill;
/**
*
*/
private createSupplement;
/**
*
*/
private getColorRamp;
/**
*
*/
private getData;
/**
*
*/
updateAttribute(attrName: any): void;
}
class JBPointRender extends RenderObject {
_positions: any[];
_svgStr: any;
ent: any;
_image: string;
_appearance: Cesium.MaterialAppearance;
_label: any;
_rectangleInstance: any;
_labelCollect: any;
_objE: HTMLDivElement;
svgCode: string;
billboard: any;
_vectorPrimitiveCollection: any[];
flagCode: any[];
private svgHelper;
private trailLineStartPosition;
private trailLineStartGeoPosition;
private trailLineEndPosition;
private billboardCollection;
private originImgWidth;
private originImgHeight;
readonly renderType: RenderTypeEnum;
/**
* 线
* @ignore
*/
/**
*
*/
init(): void;
/**
* billboard
* @param data
*/
renderByBillboard(data: any): void;
/**
* @ignore
* 线 canvas
*/
private updateTrailLineCanvas;
/**
* @ignore
* 线
*/
private getTrailEndPoint;
/**
*
* @param data
*/
renderByGrid(data: any): void;
/**
* Appearence
*/
createAppearence(): Cesium.PerInstanceColorAppearance;
/**
*
* @param data
*/
renderByVector(data: any): void;
/**
*
* @param data
*/
JBLoad(data: any): void;
/**
* threejs svgLoader解析后的svg数据
* @param shape
* @param data
*/
analysis(shape: any, data: any): void;
/**
*
* @param holesRes
* @param height
* @param extrudedHeight
* @param color
* @param holes
* @param holesColor
*/
createVector(holesRes: any, height: any, extrudedHeight: any, color: any, holes?: any, holesColor?: any): void;
/**
*
* @param holes
* @param position
*/
calcholes(holes: any, position: any): any;
update(): void;
/**
*
*/
updateAttribute(attrName: any): void;
updateHole(holes: any, color: any): any;
modifySvg(code: any, color: any, strokeWidth: any, strokeColor: any, callback: any): void;
parseDom(arg: any): NodeListOf<Element>;
getSVG(): string;
SVG(svg: any): string;
clear(): void;
/**
* @ignore
*
* PS JB
*/
getCurrectOffset(): number[];
}
class Corner {
pos: Cesium.Cartesian3;
center: Cesium.Cartesian3;
radius: number;
pre: Cesium.Cartesian3;
nxt: Cesium.Cartesian3;
circleNum: number;
constructor(opt: any);
}
class CirclePipeCornerGeometry extends PipelineGeometry {
private _corners;
/**
* 线
* center
*
* / radius
* /
* pre /___
* pos nxt
* @param cornerArray
* @param radius
*/
constructor(cornerArray: Array<Corner>, radius: number, shape: SectionShape);
protected building(): void;
getCorners(): Corner[];
getLineIndices(): any[];
getTriangleIndices(): any[];
}
class CirclePipelineGeometry extends PipelineGeometry {
private _pts;
/**
* 线
* @param pts pts是由线段组成
* @param radius
*/
constructor(pts: Array<Cesium.Cartesian3>, radius: number, shape: SectionShape);
protected building(): void;
getLineIndices(): any[];
getTriangleIndices(): any[];
}
class PipelineBaseRender extends RenderObject {
protected _primitiveLines: Cesium.Primitive;
protected _lineApp: Cesium.MaterialAppearance;
protected _polyApp: Cesium.MaterialAppearance;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
clear(): void;
/**
* 线appearance
* @param c
*/
protected createLineAppearance(c: Cesium.Color): any;
/**
* appearance
* @param c
* @param image
*/
protected createPolyAppearance(c: Cesium.Color, image: string): any;
/**
*
*/
private getMS1;
/**
*
*/
private getMS2;
/**
* geometry对象
* @param vertexs
* @param nors 线
* @param sts
* @param inds
* @param type Cesium.PrimitiveType.LINESCesium.PrimitiveType.TRIANGLES
*/
protected createGeometry(vertexs: any, nors: any, sts: any, inds: any, type: any): Cesium.Geometry;
protected createLineGeometry(): any[];
protected createTriangleGeometry(): any[];
protected createPrimitiveLine(): void;
protected createPrimitive(): void;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
class Corner {
pos: Cesium.Cartesian3;
center: Cesium.Cartesian3;
radius: number;
pre: Cesium.Cartesian3;
nxt: Cesium.Cartesian3;
arc: Array<Cesium.Cartesian3>;
circleNum: number;
constructor(opt: any);
}
class PipelineCornerGeometry extends PipelineGeometry {
private _corners;
/**
* 线
* center
*
* / radius
* /
* pre /___
* pos nxt
* @param cornerArray
* @param radius
*/
constructor(cornerArray: Array<Corner>, radius: number, shape: SectionShape);
protected building(): void;
getCorners(): Corner[];
getLineIndices(): any[];
getTriangleIndices(): any[];
}
class PipelineGeometry {
protected _radius: number;
protected _shape: SectionShape;
protected _shapePtsNum: number;
protected _vertex: Array<Cesium.Cartesian3>;
protected _texture: Array<Cesium.Cartesian2>;
protected _normals: Array<Cesium.Cartesian3>;
constructor(radius: number, shape: SectionShape);
protected building(): void;
/**
* preMatrixv(0, -1, 0)dir方向的矩阵 ------
* @param preMatrix
* @param dir
*/
protected getRotateMatrix(preMatrix: any, dir: any): any;
radius: number;
getVertex(): Cesium.Cartesian3[];
getTexture(): Cesium.Cartesian2[];
getNormal(): Cesium.Cartesian3[];
getShapePtsNum(): number;
getLineIndices(): any;
getTriangleIndices(): any;
createLineGeometry(): Cesium.Geometry;
createTriangleGeometry(): Cesium.Geometry;
}
/// <reference path="../../../../../../src/Types/cesium.d.ts" />
/**
* 线
*/
class PipelineRender extends PipelineBaseRender {
private _circlePts;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
private getAngle;
private getStartAngle;
protected createLineGeometry(): any[];
protected createLineGeometry_(): Cesium.Geometry[];
private combineVertex;
protected createTriangleGeometry(): any[];
protected createTriangleGeometry_(): Cesium.Geometry[];
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
class PipelineSegGeometry extends PipelineGeometry {
private _pts;
/**
* 线线
* @param pts pts是由线段组成
* @param radius
*/
constructor(pts: Array<Cesium.Cartesian3>, radius: number, shape: SectionShape);
protected building(): void;
getLineIndices(): any[];
getTriangleIndices(): any[];
}
class PipelineStripGeometry extends PipelineGeometry {
/** 线
* {
* geos:Array<GeoPoint>, //中心线地理坐标
* pts:Array<Cesium.Cartesian3>, //中心线世界坐标
* types:Array<boolean> //中心线类型true表示直线段false表示曲线段
* }
*/
private _paras;
private _shapeNum;
/**
* 线线
* @param pts 线
* @param radius
*/
constructor(para: {
geos: Array<GeoPoint>;
pts: Array<Cesium.Cartesian3>;
types: Array<boolean>;
}, radius: number, shape: SectionShape);
protected building(): void;
getLineIndices(): any[];
getTriangleIndices(): any[];
}
/**
* 线
*/
class PipelineStripRender extends PipelineBaseRender {
protected _geometry: PipelineStripGeometry;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
private buildGeometry;
protected createLineGeometry(): any[];
protected createTriangleGeometry(): any[];
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
class PipelineTurnGeometry extends PipelineGeometry {
private _pts;
/**
* 线线
* @param pts 线
* @param radius
*/
constructor(pts: Array<Cesium.Cartesian3>, radius: number, shape: SectionShape);
protected building(): void;
getLineIndices(): any[];
getTriangleIndices(): any[];
}
class PipelineTurnPartGeometry extends PipelineGeometry {
private _pts;
private _types;
private _shapeNum;
protected _topAttributes: {
vertex: Array<Cesium.Cartesian3>;
texture: Array<Cesium.Cartesian2>;
normals: Array<Cesium.Cartesian3>;
types: Array<boolean>;
};
protected _bottomAttributes: {
vertex: Array<Cesium.Cartesian3>;
texture: Array<Cesium.Cartesian2>;
normals: Array<Cesium.Cartesian3>;
types: Array<boolean>;
};
/**
* 线线
* @param pts 线
* @param radius
*/
constructor(pts: Array<Cesium.Cartesian3>, types: Array<boolean>, radius: number, shape: SectionShape);
protected building(): void;
getLineIndices(): any[];
getTriangleIndices(): any[];
getTopAttributes(): {
vertex: Cesium.Cartesian3[];
texture: Cesium.Cartesian2[];
normals: Cesium.Cartesian3[];
types: boolean[];
};
getBottomAttributes(): {
vertex: Cesium.Cartesian3[];
texture: Cesium.Cartesian2[];
normals: Cesium.Cartesian3[];
types: boolean[];
};
}
class PipeMath {
/**
* z分量表示纹理偏移量
* @param span
*/
static getCircle(span?: number): any[];
/**
* z分量表示纹理偏移量
* @param span
*/
static getCirclePart(span?: number): any[];
/**
* 1.0z分量表示纹理偏移量
*/
static getRect(): any[];
/**
* 1.0z分量表示纹理偏移量
*/
static getRectPart(): any[];
/**
* 2d单位圆角矩形1.0z分量表示纹理偏移量
* @param roundAngle
*/
static getRoundRect(roundAngle?: number): any[];
/**
* 2d单位半个圆角矩形1.0z分量表示纹理偏移量
* @param roundAngle
*/
static getRoundRectPart(roundAngle?: number): any[];
/**
* 2d单位圆弧顶点
* @param beginAngle
* @param allAngle
* @param span
*/
static getPartCircle2D(beginAngle: number, allAngle?: number, span?: number): any[];
static getShapePts(shape: SectionShape): any;
static getShapePartPts(shape: SectionShape): any;
/**
* a朝向量b方向旋转angle角度的旋转矩阵
* @param a a
* @param b b
* @param angle a与b之间的夹角
*/
static getRotateMatrix(a: Cesium.Cartesian3, b: Cesium.Cartesian3, angle?: number): Cesium.Matrix3;
/**
* 线Array<Cesium.Cartesian3>
* @param preTangency
* @param pt
* @param nxtTangency
* @param center
*/
static getCornerCenterLine(preTangency: Cesium.Cartesian3, pt: Cesium.Cartesian3, nxtTangency: Cesium.Cartesian3, center: Cesium.Cartesian3): any[];
/**
*
* @param pre
* @param pos
* @param nxt
* @param r
*/
static getRoundParas(pre: Cesium.Cartesian3, pos: Cesium.Cartesian3, nxt: Cesium.Cartesian3, r: number): {
center: Cesium.Cartesian3;
preTangency: Cesium.Cartesian3;
nxtTangency: Cesium.Cartesian3;
};
/**
*
* @param rect
* @param other
* @return true:; false:
*/
static isRectIntersect(rect: Cesium.Rectangle, other: Cesium.Rectangle): boolean;
/**
* 线p1p2与线段p3p4共线的14种情况isLineIntersect函数使用
* @param v p3p4
* @param a p3p1
* @param b p3p2
*/
private static sameLine2;
/**
* 线p1p2与线段p3p4共线的14种情况isLineIntersect函数使用
* @param v p1p2
* @param a p1p3
* @param b p1p4
*/
private static sameLine1;
/**
* 线
* @param p1 线1
* @param p2 线1
* @param p3 线2
* @param p4 线2
* @return 0:不相交1:相交于中间点2:p1与p3重合3:p2与p3重合4:p1与p4重合5:p2与p4重合
* 6:交点p3在p1p2线上7:交点p4在p1p2线上8:交点p1在p3p4线上9:交点p2在p3p4线上
* 10:共线14
*/
static isLineIntersect(p1: GeoPoint, p2: GeoPoint, p3: GeoPoint, p4: GeoPoint): 0 | 2 | 1 | 3 | 10 | 7 | 6 | 5 | 4 | 8 | 9;
/**
* 线p1p2与线段p3p4的交点线
* @param p1 线p1p2的起始点
* @param p2 线p1p2的终止点
* @param p3 线p3p4的起始点
* @param p4 线p3p4的终止点
*/
static getLineIntersect(p1: GeoPoint, p2: GeoPoint, p3: GeoPoint, p4: GeoPoint): GeoPoint;
/**
*
* @param pt
* @param other
*/
static isEqual(pt: GeoPoint, other: GeoPoint): boolean;
/**
* 线p1p2与线段p3p4是否平行
* @param p1
* @param p2
* @param p3
* @param p4
* @return true:false:
*/
static isParallel(p1: GeoPoint, p2: GeoPoint, p3: GeoPoint, p4: GeoPoint): boolean;
}
/**
* 线
*/
class PipeTurnThreeRender extends PipelineBaseRender {
private _creatorArray;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
private isRight;
private isLeft;
private getAngle;
/**
* 线
* @param attributeArr
* @param vertexs
* @param nors 线
* @param sts
* @return *2object对象
* {
* indexArr:Array<number>, //半个拐弯顶点索引
* hasArc: boolean //拐弯线段中是否包含曲线段
* }
*/
private getAttributes;
private buildLineIndexByArray;
private buildTriangleIndexByArray;
/**
* 线
* @param partIndexArr
* @param vertexs
*/
private getLineIndexArray;
/**
*
* @param partIndexArr
* @param vertexs
* @param isLine 线false
*/
private getIndexArray;
private createGeometryCreator;
protected createLineGeometry(): any[];
protected createTriangleGeometry(): any[];
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
/**
* 线
*/
class PipeTurnTwoRender extends PipelineBaseRender {
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
protected createLineGeometry(): any[];
protected createTriangleGeometry(): any[];
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
}
class GxPrimitivePolyline {
private vertexShader;
private fragmentShader;
private viewer;
private positionArr;
private colorArr;
private indiceArr;
/**
* Geomerty
*/
geometry: Cesium.Geometry;
/**
* Appearance
*/
appearance: Cesium.Appearance;
/**
*
* @param viewer
* @param Cartesians ,
* @param Colors ,Cartesians的4倍[1][1][1][0],4
*/
constructor(viewer: Cesium.Viewer, Cartesians: Array<Cesium.Cartesian3>, Colors: Array<number>);
private CreateGeometry;
private CreateAppearence;
private getVS;
private getFS;
}
/**
*
*/
class GxPrimitiveTriangles {
private vertexShader;
private fragmentShader;
private viewer;
private positionArr;
private colorArr;
private indiceArr;
/**
* Geomerty
*/
geometry: Cesium.Geometry;
/**
* Appearance
*/
appearance: Cesium.Appearance;
/**
*
* @param viewer
* @param Cartesians ,
* @param Colors ,Cartesians的4倍[1][1][1][0],4
*/
constructor(viewer: Cesium.Viewer, Cartesians: Array<Cesium.Cartesian3>, Colors: Array<number>);
private CreateGeometry;
private CreateAppearence;
private getVS;
private getFS;
}
class RadarNodeRender extends RenderPositionObject {
private _sphereVertex;
private _sphereTriangle;
private _sphereLines;
private _sphereCone;
private _scanPlane;
private _primitiveOut;
private _primitiveLine;
private _primitiveCone;
private _primitiveScan;
private _primitiveScanLine;
private _posMatrix;
private _lastTime;
private _rotateAngle;
private _isReserve;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
readonly renderType: RenderTypeEnum;
init(): void;
/**
*
*/
protected dataUpdate(): void;
/**
* Geometry
*/
private createGeometry;
/**
* Primitive
*/
private createPrimitive;
/**
*
*/
private createOutPrimitive;
/**
* 线
*/
private createLinePrimitive;
/**
*
*/
private createConePrimitive;
/**
*
*/
private createScanPrimitive;
private getModelMatrix;
private getScanModelMatrix;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class RadarRender extends RenderObject {
private primitivePolyline;
private primitiveTriangles;
private scanPrimitivePolyline;
private scanPrimitiveTriangles;
isPrimitive: boolean;
private radarOption;
private _position;
private angle;
private isReserve;
private lastTime;
readonly renderType: RenderTypeEnum;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
listenerFun: () => void;
position: GeoPoint;
private create;
private createScan;
private originalMatrix;
private updateModelMatrix;
private createPrimitive;
/**
* ,
*/
update(): void;
/**
*
* @param attrName
*/
updateAttribute(attrName: any): void;
/**
*
*/
clear(): void;
}
class ScanPlane {
geometry: Cesium.Geometry;
geometryLines: Cesium.Geometry;
appearance: Cesium.Appearance;
appearanceLines: Cesium.Appearance;
private positions;
private colors;
private indices;
private _obj;
constructor(obj: SphereVertex);
createAppearance(c: Cesium.Color): any;
/**
*
*/
private getMS;
private createLineAppearance;
private getFS;
private getVS;
createGeometry(fileScan: boolean): void;
createLineGeometry_1(): void;
createLineGeometry(c: Cesium.Color): void;
}
class SphereCone {
geometry: Cesium.Geometry;
appearance: Cesium.Appearance;
private _obj;
constructor(obj: SphereVertex);
createAppearance(c: Cesium.Color): any;
/**
*
*/
private getMS;
createGeometry(): void;
}
class SphereLines {
geometry: Cesium.Geometry;
appearance: Cesium.Appearance;
private _obj;
constructor(obj: SphereVertex);
createAppearance(c: Cesium.Color): any;
/**
*
*/
private getMS;
createGeometry(): void;
}
class SphereTriangles {
geometry: Cesium.Geometry;
appearance: Cesium.Appearance;
private _obj;
constructor(obj: SphereVertex);
createAppearance(c: Cesium.Color): any;
/**
*
*/
private getMS;
createGeometry(): void;
}
class SphereVertex {
private _radius;
private _horStart;
private _horEnd;
private _verStart;
private _verEnd;
private _thick;
private _slice;
private _pts;
private _texs;
private _normals;
private _hNum;
private _vNum;
private _ptsScan;
private _texScan;
private _norScan;
private _hNumScan;
private _offset;
constructor(radius: number, horStart: number, horEnd: number, verStart: number, verEnd: number, thick: number);
setParas(radius: number, horStart: number, horEnd: number, verStart: number, verEnd: number, thick: number): void;
offset: Cesium.Cartesian3;
/**
*
*/
private calculateVertexAndTextures;
/**
* (horizonNumber + 1) * (verticalNumber + 1)
*/
readonly vertexs: any[];
/**
*
*/
readonly textures: any[];
/**
* 线
*/
readonly normals: any[];
/**
*
*/
readonly horizonNumber: number;
/**
*
*/
readonly verticalNumber: number;
/**
*
*/
readonly vertexScan: any[];
/**
*
*/
readonly textureScan: any[];
/**
* 线
*/
readonly normalScan: any[];
/**
*
*/
readonly horizonNumberScan: number;
}
/**
*
*/
class RenderObject {
_renderObj: any;
_dataItem: GraphicItem;
_renderRoot: any;
_viewer: Cesium.Viewer;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
readonly renderType: RenderTypeEnum;
readonly renderObj: any;
/**
*
*/
init(): void;
/**
*
*/
clear(): void;
/**
*
*/
update(framestate: any): void;
/**
*
*/
updateAttribute(attrName: string): void;
}
enum RenderTypeEnum {
Entity = "entity",
Primitive = "Primitive",
PostProcess = "PostProcess",
Lable = "Lable",
Billboard = "Billboard",
DrawCombination = "DrawCombination",
HtmlItem = "html"
}
/**
*
*/
class RenderPositionObject extends RenderObject {
protected _listener: Function;
protected _needClock: boolean;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
* dataUpdate成员函数执行更新
* @param b dataUpdate成员函数
*/
addUpdateCallback(b?: boolean): void;
removeUpdateCallback(): void;
/**
*
*/
protected dataUpdate(): void;
/**
*
*/
updateAttribute(attrName: string): void;
clear(): void;
}
/**
*
*/
class RenderUtils {
constructor();
static getPositions(value: Array<GeoPoint>): any[];
static getRadii(value: any): Cesium.Cartesian3;
static getRectangleDegress(value: any): Cesium.Rectangle;
static getImage(value: any, transparent?: Boolean): Cesium.ImageMaterialProperty;
static getClassificationType(value: any): any;
static getShadows(value: any): any;
static getGranularity(value: any): number;
static getColor(value: any): Cesium.Color;
static getDynamicColor(value: String): Cesium.CallbackProperty;
static getDynamicValue(value: any): Cesium.CallbackProperty;
static getPosition(value: GeoPoint): Cesium.Cartesian3;
static getNearFarScalar(value: any): Cesium.NearFarScalar;
static getDynamicNearFarScalar(value: any): Cesium.CallbackProperty;
static getDistanceDisplayCondition(value: any): Cesium.DistanceDisplayCondition;
static getDynamicDistanceDisplayCondition(value: any): Cesium.CallbackProperty;
static getCartesian2(value: any): Cesium.Cartesian2;
static getVerticalOrigin(str: any): any;
/**
*
*/
static getHorizontalOrigin(str: any): any;
static getHeightReference(str: any): any;
static getStyle(value: any): number;
static getPositionDegrees(value: any): Cesium.Cartesian3;
static getCartesian3(value: any): Cesium.Cartesian3;
static getOrientation(position: any, hpr: any): any;
static getHpr(heading: any, pitch: any, roll: any): Cesium.HeadingPitchRoll;
static getHeading(value: any): number;
}
class ScanEffect extends RenderPositionObject {
private polygonAppearance;
private polylineAppearance;
private polygonGeometry;
private polylineGeometry;
private polygonPrimitive;
private polylinePrimitive;
private angle;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
protected dataUpdate(): void;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
private createGeometry;
/**
*
*/
private createAppearence;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
private getMS;
private createGeometryMatrix;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class ScreenTextRender extends RenderObject {
private _originProps;
private _resProps;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
readonly renderType: RenderTypeEnum;
init(): void;
/**
*
*/
updateAttribute(attrName: any): void;
private _dealResProps;
getHtmlText(): any;
updateAttributeForEditing(): void;
private _updateAllProp;
}
class SectorSensor extends RenderObject {
private _geometry;
private _appearance;
private _radius;
readonly renderType: RenderTypeEnum;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
listenerFun: () => void;
update(): void;
/**
*
*/
updateAttribute(attrName: any): void;
/**
* attribute
*/
private createGeometeryAttribute;
/**
*
* @param postionsTemp
* @param stsTemp
*/
private createGrometry;
/**
*
*/
private createMaterial;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
private createGeometryMatrix;
clear(): void;
}
class SensorRender extends RenderPositionObject {
dataOptions: any;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
update(): void;
}
class SpreadCircleClampRender extends SpreadCircleRender {
private _animation;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
protected clampToGround(): boolean;
protected onViewChanged(): void;
protected dataUpdate(): void;
/**
*
*/
private animate;
/**
*
*/
protected getMaterialFS(): string;
/**
*
*/
updateAttribute(attrName: any): void;
/**
*
*/
clear(): void;
}
class SpreadCircleLineRender extends SpreadCircleRender {
private _renderType;
private _animation;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
protected clampToGround(): boolean;
protected onViewChanged(): void;
protected dataUpdate(): void;
/**
*
*/
private animate;
/**
*
*/
protected getMaterialFS(): any;
protected getMultipleFs(): string;
protected getSingleFs(): string;
/**
*
*/
updateAttribute(attrName: any): void;
/**
*
*/
clear(): void;
}
class SpreadCircleRampRender extends SpreadCircleRender {
private _animation;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
protected clampToGround(): boolean;
protected onViewChanged(): void;
protected dataUpdate(): void;
/**
*
*/
private animate;
protected getMaterial(): Cesium.Material;
/**
*
*/
protected getMaterialFS(): string;
/**
*
*/
updateAttribute(attrName: any): void;
/**
*
*/
clear(): void;
}
/**
*
* SpreadCircleLineRender
* SpreadCircleClampRender
* SpreadCircleRampRender
* SpreadCircleRingRender
*/
class SpreadCircleRender extends RenderPositionObject {
protected _duration: number;
private _buildGeometry;
private _viewChange;
protected _offset: Cesium.Cartesian3;
protected _appearance: Cesium.Appearance;
protected _groundPrimitive: Cesium.GroundPrimitive;
protected _primitive: Cesium.Primitive;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
protected onViewChanged(): void;
/**
*
* @readonly
* @type {RenderTypeEnum}
*/
readonly renderType: RenderTypeEnum;
protected clampToGround(): boolean;
/**
* getMaterial函数
*/
protected getMaterialFS(): string;
/**
*
*/
protected getMaterial(): Cesium.Material;
/**
* Appearence
*/
protected createAppearence(): void;
private getFS;
private getVS;
protected getMatrix(): Cesium.Matrix4;
protected createGeometry3D(): Cesium.Geometry;
protected createPolygonGeometry(): any;
/**
*
*/
protected createGeometry2D(): Cesium.Geometry;
/**
* primitive
*/
protected createPrimitive(clamp: boolean): void;
/**
*
*/
updateAttribute(attrName: any): void;
/**
*
*/
clear(): void;
}
class SpreadCircleRingRender extends SpreadCircleRender {
private _renderType;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
*/
init(): void;
protected onViewChanged(): void;
/**
*
*/
protected dataUpdate(): void;
protected getMaterial(): Cesium.Material;
/**
*
*/
private getSolidFs;
/**
*
*/
protected getRampFs(): string;
/**
*
*/
private getStripFs;
/**
*
*/
updateAttribute(attrName: any): void;
/**
*
*/
clear(): void;
}
class SpreadEffect extends RenderPositionObject {
/**位置 */
private position;
/**半径 */
private radius;
/**颜色 */
private spreadColor;
/**网格体 */
private spreadGeometry;
/**材质 */
private spreadAppearance;
private scale;
private speed;
readonly renderType: RenderTypeEnum;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
protected dataUpdate(): void;
/**
*
*/
init(): void;
/**
*
*/
private createGeometry;
private createGeometryMatrix;
/**
*
*/
private createAppearence;
/**
*
*/
private getMS;
/**
* primitive
*/
private createPrimitive;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class TriangleMesh extends RenderObject {
_indices: number[];
readonly renderType: RenderTypeEnum;
_triPrimitive: any;
_viewer: any;
_points: Array<number>;
_color: string;
init(): void;
create(): void;
formatData(): {
points: number[];
indices: number[];
colors: Float32Array;
};
/**
*
* @param {*} inputs // minX,minY,maxX,maxY,png[string/url]
* @param {*} callback // instance obj
*/
draw_triangles(inputs: any, callback: any): void;
getVS(): string;
getFS(): string;
createAppearance(): Cesium.Appearance;
clear(): void;
update(): void;
/**
*
*/
updateAttribute(attrName: any): void;
}
class TruncatedConeParticleRender extends RenderPositionObject {
private _appearance1;
private _appearance2;
private _appearance3;
private _buildGeometry;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
* @readonly
* @type {RenderTypeEnum}
*/
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
private createCirclesImage;
private createConeImage;
protected createAppearence(): void;
protected createPrimitive(): void;
private createParticleGeometry;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class TruncatedConeRender extends RenderPositionObject {
private _appearance1;
private _appearance2;
private _appearance3;
private _buildGeometry;
constructor(item: GraphicItem, renderRoot: GraphicLayer);
/**
*
* @readonly
* @type {RenderTypeEnum}
*/
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
protected dataUpdate(): void;
private createPartOneImage;
private createPartTwoImage;
private createPartThreeImage;
protected createAppearence(): void;
protected createPrimitive(): void;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
}
class WaterEffect extends RenderObject {
private _fragmentShader;
private _appearance;
private _geometry;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
* @return {string}
*/
private fSWaterFace;
/**
*
* @returns
*/
private createAppearence;
/**
*
*/
updateAttribute(attrName: any): void;
clear(): void;
/**
*
* @return {string}
*/
private normalMap;
}
class WaterFace extends RenderObject {
_pointsToCartographic: any;
_waterColor: any;
_refractColor: any;
_reflectColor: any;
_waveWidth: any;
_flowDirection: any;
_flowSpeed: any;
_normalTexture: any;
_m_startTime: any;
_reflectCamera: any;
_reflectPassState: any;
_initialized: Boolean;
_drawCommand: any;
_visible: Boolean;
_waterPolygon: any;
_zFactor: any;
_lonMin: any;
_latMin: any;
_waterCenterPos: any;
m_spNormalTexture: any;
_fScale: any;
invWorldViewMatrix: any;
modelMatrix: any;
modelViewMatrix: any;
modeiViewProjection: any;
_fElapse: any;
_frameTime: any;
_flowAngle: any;
_uniformMap: any;
_waterGeometry: any;
constructor(options: WaterFaceItem, renderRoot?: GraphicLayer);
init(): void;
updateAttribute(key: any): void;
readonly renderType: RenderTypeEnum;
waterPolygon: any;
waterColor: any;
flowSpeed: any;
flowDirection: any;
waveWidth: any;
visible: Boolean;
computeBoundingRectangle(): void;
initialize(framestate: any): void;
update(frameState: any): void;
updateReflectTexture(frameState: any): void;
renderColorTexture(frameState: any, passState: any, camera: any): void;
destroy(): void;
}
class WeatherParticle extends RenderObject {
private _rainVelocity;
private _snowVelocity;
private _weatherType;
readonly renderType: RenderTypeEnum;
/**
*
*/
init(): void;
/**
*
*/
updateAttribute(attrName: any): void;
/**
*
* @returns
*/
private createParticle;
/**
*
*/
private computeEmitterMatrix;
/**
*
* @param {any}
*/
private updateParticle;
clear(): void;
}
/**
* @注意
* @描述 线
*/
class BaseLineStyle {
protected _material: any;
/**
*@注意 使
*
*/
toJson(): void;
/**
* @注意 使
*/
getMaterial(): any;
}
/**
* @注意 使
* @描述 线
*/
class LineStyle {
static createStyle(opt: any): ColorStyle | ArrowStyle | OutlineStyle | DashStyle | GlowStyle | DynamicStyle | TextureStyle;
}
/**
*
*/
class ColorStyle extends BaseLineStyle {
private _color;
constructor(any: any);
/**
*
*/
color: any;
/**
* @注意
*/
getMaterial(): any;
toJson(): {
type: PolylineStyleEnum;
color: string;
};
}
/**
*
*/
class ArrowStyle extends BaseLineStyle {
private _color;
constructor(any: any);
/**
*
*/
color: any;
/**
*@注意 使
*
*/
toJson(): {
type: PolylineStyleEnum;
color: string;
};
}
/**
* 线
*/
class OutlineStyle extends BaseLineStyle {
private _color;
private _outlineWidth;
private _outlineColor;
constructor(any: any);
/**
*
*/
color: string;
/**
*
*/
outlineWidth: number;
/**
*
*/
outlineColor: string;
/**
*@注意 使
*
*/
toJson(): {
type: PolylineStyleEnum;
color: string;
outlineColor: string;
outlineWidth: number;
};
}
/**
* 线
*/
class DashStyle extends BaseLineStyle {
private _color;
private _gapColor;
private _dashLength;
private _dashPattern;
constructor(any: any);
/**
*
*/
color: string;
/**
*
*/
gapColor: string;
/**
* pixel中的虚线模式的长度
*/
dashLength: number;
/**
* 线16
*/
dashPattern: number;
/**
*@注意 使
*
*/
toJson(): {
type: PolylineStyleEnum;
color: string;
gapColor: string;
dashPattern: number;
dashLength: number;
};
}
/**
* 线
*/
class GlowStyle extends BaseLineStyle {
private _color;
private _glowPower;
private _taperPower;
constructor(any: any);
/**
*
*/
color: string;
/**
* 线
*/
glowPower: number;
/**
* 线1.0使
*/
taperPower: number;
/**
*@注意 使
*
*/
toJson(): {
type: PolylineStyleEnum;
color: string;
taperPower: number;
glowPower: number;
};
}
/**
* 线
*/
class DynamicStyle extends BaseLineStyle {
private _icon;
private _color;
private _duration;
private _update;
constructor(any: any);
private _updateMaterial;
/**
*@注意 使
*
*/
setUpdate(value: any): void;
/**
* 线
*/
icon: DynamicIconEnum;
/**
*
*/
color: string;
/**
*
*/
duration: number;
/**
*@注意 使
*
*/
toJson(): {
type: PolylineStyleEnum;
icon: DynamicIconEnum;
color: string;
duration: number;
};
}
class TextureStyle extends BaseLineStyle {
private _icon;
private _color;
private _revert;
private _dynamic;
private _speed;
private _update;
constructor(any: any);
private _updateMaterial;
/**
*@注意 使
*
*/
setUpdate(value: any): void;
/**
* 线
*/
icon: TextureIconEnum;
/**
* 默认:false
*/
dynamic: boolean;
/**
* 默认:1.0
*/
speed: number;
/**
*
*/
color: string;
/**
*@注意 使
*
*/
toJson(): {
type: PolylineStyleEnum;
icon: TextureIconEnum;
color: string;
};
}
/**
* 线
*/
enum DynamicIconEnum {
Arrow = "arrow",
Pulse = "pulse",
Trail = "trail",
Attack = "attack"
}
/**
* 线
*/
enum TextureIconEnum {
/**
*
*/
WireNetting = "WireNetting",
/**
*
*/
IronBar = "IronBar",
/**
* 线
*/
LinkPulse = "LinkPulse"
}
/**
* 线
*/
enum PolylineStyleEnum {
/**
*
*/
Color = "Color",
/**
*
*/
Arrow = "PolylineArrow",
/**
* 线
*/
Dash = "PolylineDash",
/**
* 线
*/
Glow = "PolylineGlow",
/**
* 线
*/
Outline = "PolylineOutline",
/**
* 线
*/
Dynamic = "Dynamic",
/**
* 线线
*/
Texture = "Texture"
}
class PipelineManager extends Layer {
protected _viewer: Cesium.Viewer;
protected _graphicLayer: GraphicLayer;
protected _itemList: Array<PipelineBaseGraphic>;
protected _topoList: Array<TopologyNode>;
protected _idNum: number;
protected _cameraControl: FirstPersonControl;
constructor(viewer: Cesium.Viewer, layer: GraphicLayer);
private deleteGraphicLine;
private searchTopoNode;
private updateTopoNode;
private copyLine;
private processBreakupByPoint;
private processBreakup;
private processHead;
private processTail;
/**
*
* @param item
* @param ohter
*/
private building;
/**
*
* @param item
*/
buildTopologySingle(item: PipelineStripGraphic): void;
/**
*
* @param needClear false, true:/
*/
buildTopology(needClear?: boolean): void;
/**
*
*/
clearTopology(): void;
/**
*
*/
updatePipeTurnGraphic(): void;
flyToPipeline(line: PipelineStripGraphic): void;
exitFly(): void;
}
/**
*
*/
class TopologyNode {
protected _graphicLayer: GraphicLayer;
protected _id: any;
protected _geo: GeoPoint;
protected _position: Cesium.Cartesian3;
protected _lines: Array<PipelineStripGraphic>;
protected _isHeads: Array<boolean>;
protected _graphic: PipelineTurnGraphic;
constructor(id: number, layer: GraphicLayer, pt: GeoPoint);
readonly id: any;
readonly geo: GeoPoint;
readonly pos: Cesium.Cartesian3;
readonly graphic: PipelineTurnGraphic;
getTopoLines(): PipelineStripGraphic[];
getIsHeads(): boolean[];
/**
* 线
* @param item 线
*/
has(item: PipelineStripGraphic): boolean;
/**
* 线
* @param item 线
* @param isHead 线false表示尾点
*/
addTopoLine(item: PipelineStripGraphic, isHead: boolean): void;
/**
* 线
* @param item 线
* @param isHead 线false表示尾点
*/
removeTopoLine(item: PipelineStripGraphic, isHead: boolean): void;
/**
* 线线
* @param item 线
* @param isHead 线false表示尾点
*/
recovery(item: PipelineStripGraphic, isHead: boolean): void;
/**
*
*/
clear(): void;
/**
*
*/
createOrUpdateGraphic(): void;
private createTurnTwo;
private updateTurnTwo;
private createTurnThree;
private updateTurnThree;
}
/**
* UrlTemplate影像
*/
class ArcGisImagery extends ImageryItem {
private _renderObj;
private _imageLayer;
private _option;
protected _type: string;
constructor(option: ArcGisImageryOpt);
/**
*
*/
getType(): string;
static readonly type: string;
initItem(imageLayer: ImageLayer): void;
destroyItem(): void;
getRenderObject(): Cesium.ImageryLayer;
parseOption(option: any): void;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(option: any): void;
}
class ArcGisImageryOpt {
/**
*
*/
url: string;
}
/**
* @类型 Cesium扩展类
* @描述
* @see <a href='../../../examples/gallery/editor.html#baiduImagery'></a>
*/
class BaiduImageryProvider {
private _errorEvent;
private _tileWidth;
private _tileHeight;
private _maximumLevel;
private _minimumLevel;
private _tilingScheme;
private _rectangle;
private _tileDiscardPolicy;
private _credit;
private _readyPromise;
private _resource;
constructor(options: any);
private readonly url;
private readonly proxy;
private readonly tileWidth;
private readonly tileHeight;
private readonly maximumLevel;
private readonly minimumLevel;
private readonly tilingScheme;
private readonly tileDiscardPolicy;
private readonly rectangle;
private readonly errorEvent;
private readonly ready;
private readonly readyPromise;
private readonly credit;
private requestImage;
}
/**
* UrlTemplate影像
*/
class BingImagery extends ImageryItem {
private _renderObj;
private _imageLayer;
private _option;
private _type;
constructor(option: BingImageryOpt);
/**
*
*/
getType(): string;
static readonly type: string;
initItem(imageLayer: ImageLayer): void;
destroyItem(): void;
getRenderObject(): Cesium.ImageryLayer;
parseOption(option: any): void;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(option: any): void;
}
class BingImageryOpt {
/**
*
*/
url: string;
/**
*
*/
key: string;
}
class ImageLayer extends Layer {
_viewer: Cesium.Viewer;
_renderItemList: any[];
constructor(viewer: Cesium.Viewer);
/**
*
* @param item
*/
add(item: Item): Item;
/**
*
* @param
*/
remove(itemid: string): Item;
/**
*
* @param image
*/
lower(image: ImageryItem): void;
/**
*
* @param image
*/
lowerToBottom(image: ImageryItem): void;
/**
*
* @param image
*/
raise(image: ImageryItem): void;
/**
*
* @param image
*/
raiseToTop(image: ImageryItem): void;
/**
* json
* @param json
*/
parseJson(json: any): void;
getItemList(): Item[];
/**
*
*/
getRenderObject(): Cesium.ImageryLayerCollection;
getRenderItemById(id: string): any;
}
/**
*
*/
enum TilingSchemeE {
/**
* web墨卡托投影
*/
WebMercator = 1,
/**
* Wgs84投影
*/
Geographic = 2
}
/**
*
*/
class TilingSchemeParse {
static getTilingScheme(e: TilingSchemeE): Cesium.TilingScheme;
}
class ImageryItem extends Item {
getRenderObject(): Cesium.ImageryLayer;
}
/**
* OSM影像
*/
class OSMImagery extends ImageryItem {
private _renderObj;
private _imageLayer;
private _option;
private _type;
constructor(option: OSMImageryOpt);
/**
*
*/
getType(): string;
static readonly type: string;
initItem(imageLayer: ImageLayer): void;
destroyItem(): void;
getRenderObject(): Cesium.ImageryLayer;
parseOption(option: any): void;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(option: any): void;
}
class OSMImageryOpt {
/**
*
*/
url: string;
/**
*
*/
maximumLevel: number;
}
/**
* UrlTemplate影像
*/
class UrlTemplateImagery extends ImageryItem {
private _renderObj;
private _imageLayer;
private _option;
private _type;
constructor(option: UrlTemplateImageryOpt);
/**
*
*/
getType(): string;
static readonly type: string;
initItem(imageLayer: ImageLayer): void;
destroyItem(): void;
getRenderObject(): Cesium.ImageryLayer;
parseOption(option: any): void;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(option: any): void;
}
class UrlTemplateImageryOpt {
/**
*
*/
url: string;
/**
*
*/
tilingScheme: TilingSchemeE;
/**
*
*/
maximumLevel: number;
}
/**
* UrlTemplate影像
*/
class WMSImagery extends ImageryItem {
private _renderObj;
private _imageLayer;
private _option;
private _type;
constructor(option: WMSImageryOpt);
/**
*
*/
getType(): string;
static readonly type: string;
initItem(imageLayer: ImageLayer): void;
destroyItem(): void;
getRenderObject(): Cesium.ImageryLayer;
parseOption(option: any): void;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(option: any): void;
}
class WMSImageryOpt {
/**
*
*/
url: string;
/**
*
*/
layer: string;
/**
*
*/
tilingScheme: TilingSchemeE;
/**
*
*/
style: string;
/**
*
*/
format: string;
/**
*
*/
tileMatrixSetID: string;
}
/**
* UrlTemplate影像
*/
class WMTSImagery extends ImageryItem {
private _renderObj;
private _imageLayer;
private _option;
private _type;
constructor(option: WMTSImageryOpt);
/**
*
*/
getType(): string;
static readonly type: string;
initItem(imageLayer: ImageLayer): void;
private _parseUrl;
destroyItem(): void;
getRenderObject(): Cesium.ImageryLayer;
parseOption(option: any): void;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(option: any): void;
}
class WMTSImageryOpt {
/**
*
*/
url: string;
/**
*
*/
layer: string;
/**
*
*/
tilingScheme: TilingSchemeE;
/**
*
*/
style: string;
/**
*
*/
format: string;
/**
*
*/
tileMatrixSetID: "EPSG:4326";
}
/**
*
*/
class LayerManager {
private _graphicLayer;
private _ImageLayer;
private _vectorLayer;
private _modelLayer;
private _massiveLayer;
private _targetLayer;
private _terrainLayers;
private _satelliteLayer;
private _tileLayer;
private _actionLayer;
private _viewer;
constructor(viewer: Cesium.Viewer);
init(): void;
toJson(): {
graphicLayer: object;
imageLayer: any[];
vectorLayer: any[];
modelLayer: any[];
actionLayer: {
baseTime: string;
actionGroups: any[];
graphics: object;
} | {
baseTime: string;
actionGroups: any[];
graphics?: undefined;
};
};
/**
* json
* @param json
*/
parseJson(json: any): void;
/**
*
*/
readonly graphicLayer: GraphicLayer;
/**
*
*/
readonly imageLayer: ImageLayer;
/**
* kml kmz geojson矢量图层
*/
readonly vectorLayer: VectorLayer;
/**
* 3dtiles
*/
readonly modelLayer: ModelLayer;
/**
*
*/
readonly massiveLayer: MassiveLayer;
/**
*
*/
readonly targetLayer: TargetLayer;
/**
*
*/
readonly terrainLayers: TerrainLayerCollection;
/**
*
*/
readonly satelliteLayer: SatelliteLayer;
/**
*
*/
readonly tileLayer: TileLayer;
/**
*
*/
readonly actionLayer: ActionLayer;
}
/**
* @类别 <br>
* @描述 <br>
* @see <a href='../../../examples/gallery/editor.html#cluster'></a>
*/
class Cluster extends Item {
private _customDataSource;
private _viewer;
private _options;
private _dataSource;
private _customStyleListener;
private _customStyleEnable;
/**
*
* ```
*
* cluster.addToEarth().then(()=>{
* // 设置参数
* cluster.customStyleEnable = true;
* })
* ```
*/
customStyleEnable: boolean;
private _pixelRange;
/**
*
* ```
*
* cluster.addToEarth().then(()=>{
* // 设置参数
* cluster.pixelRange = 20;
* })
* ```
*/
pixelRange: number;
private _minimumClusterSize;
/**
*
* ```
*
* cluster.addToEarth().then(()=>{
* // 设置参数
* cluster.minimumClusterSize = 30;
* })
* ```
*/
minimumClusterSize: number;
private _enable;
/**
*
* ```
*
* cluster.addToEarth().then(()=>{
* // 设置参数
* cluster.enable = true;
* })
* ```
*/
enable: boolean;
/**
*
* @param options
* ```
*
* var clusterOpt = new GV.ClusterOpt();
* clusterOpt.name = "cluster";
* clusterOpt.pixelRange = 10;
* clusterOpt.minimumClusterSize = 5;
* clusterOpt.enable = true;
* clusterOpt.customStyleEnable = true;
* clusterOpt.setImage = setImage;
* var cluster = new GV.Cluster(clusterOpt);
* ```
*/
constructor(options: ClusterOpt);
/**
*
* @param viewer
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
/**
*
*/
toJson(): object;
/**
*
*/
parseJson(): void;
/**
*
* @param {Cesium.Entity} entity
*/
addPoint(entity: any): void;
/**
* ,
*/
addToEarth(): Promise<void>;
private _customStyleOpen;
private _resetStyle;
private _cluster;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
}
/**
*
*/
class ClusterOpt {
/**
*
*/
name: string;
/**
* id
*/
id: string;
/**
*
*/
pixelRange: number;
/**
*
*/
minimumClusterSize: number;
/**
*
*/
enable: boolean;
/**
*
*/
customStyleEnable: boolean;
/**
* size billboard
*/
setImage: Function;
}
/**
* @类别 </br>
* @描述 </br>
* @see <a href='../../../examples/gallery/editor.html#heatMap'></a>
*/
class HeatMap {
private _viewer;
private _heatMapOption;
private _heatMapLayer;
private _zoomLevel;
private _zoomRadius;
private _zAxisHeight;
private _heatMapParams;
private _moveEnd;
private _radiusRate;
private _rejustHeight;
constructor(heatOpt: HeatMapOpt);
private _calcBound;
private _formatPoints;
private _updateFllowCamera;
/**
*
* @param viewer
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
getHeatMapOpt(): any;
/**
*
*/
setRadiusRate(val: number): void;
/**
*
*/
setRejustHeight(val: number): void;
/**
*
* @param opt
*/
update(opt: HeatMapOpt): void;
/**
*
* @param opt
*/
private _create;
/**
*
*/
destroyItem(): void;
}
/**
* @类别 </br>
* @描述 </br>
* @see <a href='../../../examples/gallery/editor.html#heatMap'></a>
*/
class HeatMapOpt {
/**
* </br>
* [{}...] </br>
* {lon:80,lat:40,value:90}
*/
points: any;
/**
* </br>
* 10 </br>
* >0 && <=100
*/
radius: number;
/**
*
*/
limitMin: number;
/**
*
*/
limitMax: number;
/**
* [0,1] </br>
* { 0.25: "rgb(0,0,255)", 0.55: "rgb(0,255,0)", 0.85: "yellow", 1.0: "rgb(255,0,0)" }
*/
gradient: object;
/**
* </br>
* >=0 && <=1
*/
opacity: number;
/**
* </br>
* >=0 && <= 1
*/
blur: number;
constructor(points: any, radius: number, limitMin: number, limitMax: number, gradient?: object, opacity?: number, blur?: number);
}
/**
* @类别 </br>
* @描述 MapV复合可视化MapV之间的桥梁MapV应用请参见MapV官网https://mapv.baidu.com/</br>
* @see <a href='../../../examples/gallery/editor.html#honeyComb'></a>
* @see <a href='../../../examples/gallery/editor.html#migrate'></a>
* @see <a href='../../../examples/gallery/editor.html#weiboPoint'></a>
* @see <a href='../../../examples/gallery/editor.html#migrateAll'></a>
* @see <a href='../../../examples/gallery/editor.html#square'></a>
*/
class MapV extends Item {
protected _MapV: any;
protected _viewer: any;
private _show;
private _MapVOptions;
/**
*
*/
protected _type: string;
constructor(mapvOpt: MapVOpt);
show: boolean;
/**
* mapv
* @param viewer
*/
initItem(viewer: GeoCanvas): void;
/**
* mapv
*/
destroyItem(): void;
/**
* mapv参数
*/
getMapVOpt(): MapVOpt;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* @ignore
*/
toJson(): object;
/**
* mpv更新
* @param mapvOpt
*/
update(mapvOpt: MapVOpt): void;
/**
* Mapv
* @param options
*/
create(options: MapVOpt): any;
/**
*
* @public
* @param [data]
*/
createDataSet(data: any): any;
private _initMapv;
private _DataSetAdd;
private _DataSetReset;
private _DataSetGet;
private _DataSetSet;
private _DataSetClear;
private _DataSetRemove;
private _DataSetUpdate;
private _DataSetTransferCoordinate;
private _DataSetinitGeometry;
private _DataSetGetMax;
private _DataSetGetSum;
private _DataSetGetMin;
private _DataSetUnique;
/**
*
* @param data
*/
private _getDataSet;
/**
* 线
* @param data
*/
private _getCurvePoints;
/**
*
* @param name
*/
private _getCenterByCityName;
/**
*
* @param name
*/
private _getProvinceNameByCityName;
utilCurve: {
getPoints: (data: any) => any;
};
utilCityCenter: {
getCenterByCityName: (name: any) => any;
getProvinceNameByCityName: (name: any) => any;
};
geojson: {
getDataSet: (data: any) => any;
};
/**
*
*/
DataSet: {
add: (data: any, senderId: any) => any;
Reset: () => any;
get: (args: any) => any;
set: (args: any) => any;
clear: (args: any) => any;
remove: (args: any) => any;
update: (args: any, condition: any) => any;
transferCoordinate: (data: any, transferFn: any, fromColumn: any, toColumnName: any) => any;
initGeometry: (transferFn: any) => any;
getMax: (columnName: any) => any;
getSum: (columnName: any) => any;
getMin: (columnName: any) => any;
getUnique: (columnName: any) => any;
};
}
/**
* @类别 </br>
* @描述 MapV参数类</br>
* @see <a href='../../../examples/gallery/editor.html#honeyComb'></a>
* @see <a href='../../../examples/gallery/editor.html#migrate'></a>
* @see <a href='../../../examples/gallery/editor.html#weiboPoint'></a>
* @see <a href='../../../examples/gallery/editor.html#migrateAll'></a>
* @see <a href='../../../examples/gallery/editor.html#square'></a>
*/
class MapVOpt {
/**
* mapv
*/
data: number[];
/**
* mapv参数
*/
options: any;
constructor(data?: Array<number>, options?: any);
}
class MassiveLayer extends Layer {
private _viewer;
constructor(viewer: Cesium.Viewer);
/**
*
* @param item
*/
add(item: Item): Item;
/**
*
* @param
*/
remove(value: string | Item): Item;
/**
* json
* @param json
*/
parseJson(json: any): void;
}
/**
* @类别 Cesium扩展类<br>
* @描述 线
* @see ../../../examples/gallery/editor.html#efficientLines
*/
class MassiveLines extends Item {
/**视图对象 */
private _viewer;
/**线的Primitive对象 */
private _linePrimitive;
/**材质对象 */
private _apprence;
/**纹理图片路径 */
private _lineTexTure;
/**流动线颜色 */
private _animateColor;
/**线的主体颜色 */
private _lineColor;
/**线的数据 */
private _lineData;
/**线的Instance对象数组 */
private _lineInstances;
/**流动速度 */
private _speed;
/**线的宽度 */
private _lineWidth;
/**Item编号 */
protected _id: string;
/**
*
* @param options
* @returns
* ```
*
* let data = [[90, 0, 2000000, 90, 30, 2000000]];
* let massiveLinesOpt = new GV.MassiveLinesOpt(data);
* let massiveLines = new GV.MassiveLines(massiveLinesOpt);
*
* ```
*/
constructor(options: MassiveLinesOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @return {string}
*
*/
readonly sportColor: string;
/**
* 线
* @param {string} val 线
* ```
*
* massiveLines.sportColor='#ffffff'
* ```
*/
animateColor: string;
/**
* 线
* @return {string}
*/
/**
* 线
* @param {string} val 线
* ```
*
* massiveLines.sportColor='#ffffff'
* ```
*/
lineColor: string;
/**
*
* @return {number}
*/
/**
*
* @param {number} val
* ```
*
* massiveLines.speed=1.0
* ```
*/
speed: number;
/**
*
* @return {string}
*/
/**
*
* @param {string} val
*/
lineTexture: string;
/**
*
* @param {BatchLineOptions} options
*/
initItem(viewer: GeoCanvas): void;
/**
* 线
*/
private createLineInstance;
/**
*
*/
private createMaterial;
/**
*
*/
private getMS;
/**
* 线
*/
private drawLines;
/**
* 线
*/
destroyItem(): void;
/**
* Event函数
*/
private listenerFun;
}
/**
* 线
*/
class MassiveLinesOpt {
/**已插值的线数据*/
lineData: Array<Array<number>>;
/**流动速度 */
speed?: number;
/**纹理URL*/
lineTexTure?: string;
/**流动线颜色*/
animateColor?: string;
/**线的主体颜色 */
lineColor?: string;
/**线的宽度 */
lineWidth?: number;
constructor(lineData: Array<Array<number>>, speed?: number, lineTexTure?: string, animateColor?: string, lineColor?: string, lineWidth?: number);
}
/**
* @类别 Cesium扩展类<br>
* @描述
* @see <a href='../../../examples/gallery/editor.html#efficientPoints'></a>
*/
class MassivePoints extends Item {
/**视图对象*/
private _viewer;
/**点样式划分 */
private _colors;
/**点大小 */
private _pointSizes;
/**Primitive对象 */
private _primitive;
/**材质对象 */
private _appearance;
/**点数据 */
private _data;
/**点颜色数组 */
private _pointColors;
/**点位置数组 */
private _pointPositions;
/**Item Id */
protected _id: string;
/**
*
* @param data
* @param colors
* @returns
* ```
*
* let colors=[];
* colors.push(new GV.PointStyle(1000, 0.4, 0.9, 0.2, 0.4));
* let pointData=[];
* pointData.push(new GV.PointOption(90, 0, 1000))
* let massivePoints = new GV.MassivePoints(pointData,colors);
*
* ```
*/
constructor(data: Array<PointOption>, colors: Array<PointStyle>);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @param {GeoCanvas}
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
/**
*
*/
private resolveData;
/**
*
* @return {Cesium.Geometry}
*/
private createGeometry;
/**
*
* @param {string} fs
* @param {string} vs
* @return {Cesium.Appearance}
*/
private createAppearence;
/**
*
* @return {string}
*/
private getVS;
/**
*
* @return {string}
*/
private getFS;
/**
*
* @param {number}
* @return {Array}
*/
private getColor;
/**
*
* @param {number}
* @return {number}
*/
private getPointSize;
/**
*
* @param {Array} data
*
* ```
*
* let pointData=[];
* pointData.push(new GV.PointOption(10, 0, 1000));
* massivePoints.data=pointData;
*
* ```
*/
data: Array<PointOption>;
}
/**批量绘制点参数 */
class PointOption {
/**点经度 */
lon: number;
/**点纬度 */
lat: number;
/**代表当前点个数 */
count: number;
constructor(lon: number, lat: number, count: number);
}
/**点样式设定 */
class PointStyle {
/**点个数级别 */
level: number;
/**点颜色r通道 */
r: number;
/**点颜色g通道*/
g: number;
/**点颜色b通道 */
b: number;
/**点颜色a通道 */
a: number;
constructor(level: number, r: number, g: number, b: number, a: number);
}
/**
* @类别 Cesium扩展类<br>
* @描述
* @see <a href='../../../examples/gallery/editor.html#efficientPolygons'></a>
*/
class MassivePolygons {
private _viewer;
private _dataSource;
private _instances;
private _heightFlag;
private _primitive;
protected _id: string;
/**
*
* @param {Array<PolygonOptions>} dataSource
* @param {boolean} heightFlag
* ```
*
* let dataSource=[];
* dataSource.push(new GV.MassivePolygonOpt([0, 0, 10, 0, 10, 10, 0, 10]));
* let massivePolygons=new GV.MassivePolygons(dataSource);
* ```
*/
constructor(dataSource: Array<MassivePolygonOpt>, heightFlag?: boolean);
/**
*
*/
private createInstances;
/**
*
* @return {Cesium.PerInstanceColorAppearance}
*/
private createAppearence;
/**
* Primitive
*/
private createPrimitive;
/**
*
* @param {GeoCanvas} viewer
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
/**
*
* @param id id值
* @param color
*/
changePickedColor(id: string, color?: string): void;
}
/**
*
* @param {Array} positions
* @param {string} color
*/
class MassivePolygonOpt {
/**面的顶点数据 */
positions: Array<number>;
/**面的颜色 */
color: string;
/**面的ID值 */
id: string;
constructor(positions: Array<number>, id?: string, color?: string);
}
/**
* @类别 <br>
* @描述 <br>
* @see <a href='../../../examples/gallery/editor.html#debris'></a>
*/
class SpaceDebris extends Item {
private root;
private workerArray;
private derbrisList;
private debrisMap;
private viewer;
private spaceDebrisOpts;
/**
*
* @param spaceDebrisOpts
* ```
*
* fetch("../data/satellite.json").then(r => {
* r.json().then(data => {
* var spaceDebrisData = [];
* var length = data.length;
* for (var i = 0; i < length; i++) {
* var item = data[i];
* var opt = new GV.SpaceDebrisOpt();
* opt.name = item.name;
* opt.tle1 = item.tle1;
* opt.tle2 = item.tle2
* spaceDebrisData.push(opt);
* }
* var spaceDebris = new GV.SpaceDebris(spaceDebrisData);
* viewer.layerManager.massiveLayer.add(spaceDebris);
* spaceDebris.show();
* })
* })
* ```
*/
constructor(spaceDebrisOpts: Array<SpaceDebrisOpt>);
/**
*
* @param viewer
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
*/
toJson(): object;
/**
*
*/
parseJson(): void;
/**
* 线work脚本URL
*/
private workerUrl;
/**
*
*/
show(): void;
private addDebrisItem;
}
/**
* json格式需要正确
*/
class SpaceDebrisOpt {
/**
*
*/
name: string;
/**
* 1
*/
tle1: string;
/**
* 2
*/
tle2: string;
}
/**
* 使
*/
class SpaceDebrisItem {
_currentTime: Date;
_sampleProperty: Cesium.SampledPositionProperty;
_currentPosition: any;
point: Cesium.PointPrimitive;
tle1: string;
tle2: string;
worker: Worker;
id: number;
currentTime: Date;
}
/**
* @类别 <br>
* @描述 <br>
* @see <a href='../../../examples/gallery/editor.html#windy'></a>
*/
class Windy extends Item {
private _primitives;
private SPEED_RATE;
private PARTICLES_NUMBER;
private MAX_AGE;
private BRIGHTEN;
private cesiumViewer;
private windData;
private windField;
private particles;
private lines;
private windDataObj;
/**
*
* @param data
* ```
*
* fetch("../data/windData.json").then(r => {
* r.json().then(data => {
* let windy = new GV.Windy(data);
* viewer.layerManager.massiveLayer.add(windy);
* // viewer.layerManager.massiveLayer.remove(windy.id);
* })
* })
* ```
*/
constructor(data: Array<Object>);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @param viewer
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
private initWindyData;
private _init;
private createField;
private animate;
private _parseWindJson;
private removeLines;
private _map;
private _createLineInstance;
private _drawLines;
private randomParticle;
}
/**
* Layer图层
*/
class Cesium3DTileLayer extends ModelItem {
private _renderObj;
private _modelLayer;
private _option;
private _type;
constructor(option: Cesium3DTileLayerOpt);
/**
*
*/
getType(): string;
static readonly type: string;
initItem(modelLayer: ModelLayer): void;
destroyItem(): void;
getRenderObject(): Cesium.Primitive;
parseOption(option: any): void;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(option: any): void;
}
class Cesium3DTileLayerOpt {
/**
* kml路径
*/
url: string;
}
class ModelItem extends Item {
getRenderObject(): Cesium.Primitive;
}
class ModelLayer extends Layer {
_viewer: Cesium.Viewer;
_renderItemList: any[];
constructor(viewer: Cesium.Viewer);
/**
*
* @param item
*/
add(item: Item): Item;
/**
*
* @param
*/
remove(itemid: string): Item;
/**
* json
* @param json
*/
parseJson(json: any): void;
getItemList(): Item[];
/**
*
*/
getRenderObject(): Cesium.PrimitiveCollection;
getRenderItemById(id: string): any;
}
class ConicSensor {
private satellitePos;
private _angle;
private _primitive;
private slice;
private _coverColor;
private _conicOpt;
private _swingAngle;
private _primitiveCollection;
constructor(primitiveCollection: Cesium.PrimitiveCollection, conicOpt: ConicOpt);
/**
* primitive
* @return {Cesium.Primitive}
*/
readonly conic: Cesium.Primitive;
/**
*
* @memberof ConicSensor
*/
/**
*
* @return {GeoPoint}
*/
position: GeoPoint;
/**
*
* @return {string}
*/
readonly type: string;
/**
*
* @memberof ConicSensor
*/
coverColor: string;
/**
*
* @memberof ReactangularSensor
*/
/**
*
*/
angle: number;
destroy(): void;
/**
*
* 0-45
* @memberof ConicSensor
*/
swingAngle: number;
/**
*
* @param height
* @param angle
*/
private createVertex;
/**
* vao需要数据
* @param topPosArr
* @param bottomPosArr
* @param slice
*/
private createGeometeryAttribute;
/**
* Primitive
* @param ptsTemp
* @param stsTemp
*/
private createPrimitive;
private getMS;
updateMatrix(position: Cesium.Cartesian3): void;
}
class GeoVector3 {
constructor(x: number, y: number, z: number, time: Date, speed: Cesium.Cartesian3);
x: number;
y: number;
z: number;
time: Date;
speed: Cesium.Cartesian3;
}
class ReactangularSensor {
/**卫星位置 */
private satellitePos;
/**水平开合角 */
private _xAngle;
/**垂直开合角 */
private _zAngle;
private primitive;
private scanPlanePrimitive;
private scanAngle;
private _coverColor;
private _scanColor;
private _rectangularOpt;
private _swingAngle;
private _scanShow;
private _primitiveCollection;
constructor(primitiveCollection: Cesium.PrimitiveCollection, rectangularOpt: RectangularOpt);
/**
*
* @return {Array<Cesium.Primitive>}
*/
readonly rectangle: Array<Cesium.Primitive>;
destroy(): void;
/**
*
*/
/**
*
* @return {GeoPoint}
*/
position: GeoPoint;
/**
*
* @return {number}
*/
/**
*
* @memberof ReactangularSensor
*/
xAngle: number;
/**
*
* @return {number}
*/
/**
*
* @memberof ReactangularSensor
*/
zAngle: number;
/**
*
* @return {string}
*/
readonly type: string;
/**
*
* -45-45
* @memberof ConicSensor
*/
swingAngle: number;
/**
*
* @memberof ConicSensor
*/
coverColor: string;
/**
*
* @memberof ReactangularSensor
*/
scanColor: string;
/**
*
* @memberof ReactangularSensor
*/
/**
*
* @type {boolean}
* @memberof ReactangularSensor
*/
scanShow: boolean;
/**
* 姿
* @param position
*/
updateMatrix(position: Cesium.Cartesian3): void;
/**
* 线(XY平面的旋转矩阵)
* @param position
*/
private getRotationMatrix;
/**
*
*/
private getWorldMatrix;
/**
* primitive
*/
private createPrimitive;
private getMS;
/**
*
*/
private createScanPlane;
}
/**
* @类别 <br>
* @描述 <br>
* @see ../../../examples/gallery/editor.html#satelliteShow
*/
class Satellite extends Item {
private _sampleProperty;
private _sampleSpeedProperty;
protected _name: string;
protected _id: any;
/**卫星罩类型 */
private _type;
private _viewer;
/**卫星entity的Map */
private _entitiesMap;
/**轨道数据 */
private _orbitPositions;
/**当前时间 */
private _currentTime;
/**当前位置 地球坐标系*/
private _currentPosition;
/**卫星两根数 */
private _tle;
/**卫星周期 单位:分钟*/
private _priod;
/**卫星罩对象 */
private _satelliteSensor;
private _sensorOpt;
private sateMinPixelSize;
private _clock;
private _localOrbitData;
private _opt;
/**同步轨道卫星位置 */
private _synchronousPosition;
/**同步轨道卫星传感器列表 */
private _synchronousSensorMap;
private _viewChange;
/**
*
* @param options
* @returns
* ```
*
* let sateOpt = new GV.SatelliteOpt(
* `GF-1
* 1 39766U 14029A 19051.88312325 -.00000394 00000-0 -45830-4 0 9997
* 2 39766 97.9206 150.4086 0001551 85.1013 275.0382 14.79467694256344`);
* let satellite = new GV.Satellite(sateOpt);
* viewer.satelliteLayer.add(satellite);
*
* ```
*/
constructor(options: SatelliteOpt);
/**
*
* @param {string} componentName
* ```
*
* satellite.enableComponent(SatelliteComponents.Orbit);
*
* ```
*/
enableComponent(componentName: string): void;
/**
*
* @param {string} componentName
* ```
*
* satellite.disableComponent(SatelliteComponents.Orbit);
*
* ```
*/
disableComponent(componentName: string): void;
/**
*
* @param key
* @param points
* ```
*
* satellite.addSynchronousSensor('传感器1',[
* new GV.GeoPoint(120.9340158474,24.0177786452),
* new GV.GeoPoint(120.9395350817,24.0222973323),
* new GV.GeoPoint(120.9427083183, 24.004776336675963),
* new GV.GeoPoint(120.9350803555,24.0139574843)
* ]);
* ```
*/
addSynchronousSensor(key: string, points: GeoPoint[], color?: string): void;
/**
*
* @param key
*/
removeSynchronousSensor(key: string): void;
/**
*
* @param key
*/
getSensor(key?: string): any;
/**根据与摄像机距离判断创建图标还是模型 */
private createSatImageOrModel;
/**
*
*/
private createSatImage;
/**
*
*/
private createSatModel;
/**
* Label
*/
private createLabel;
/**
*
*/
private createOrbit;
private getMS;
/**
*
*/
private createCone;
/**
*
*/
private createSquareCone;
/**
*
*/
private createGroundTrack;
private calculateRecPosition;
private calculateCirPosition;
/**
*
*/
positions: Array<GeoVector3>;
/**设置卫星当前时间,更新卫星图标/模型/文字的位置,以及卫星的姿态 */
private time;
/**
*
*/
synchronousPosition: GeoPoint;
/**
* id
* @readonly
* @memberof Satellite
*
*/
readonly id: string;
/**
*
* @param viewer
*/
initItem(viewer: Cesium.Viewer): any;
protected calculatePositions3D(t: any, tle1: any, tle2: any): void;
protected calculatePositions2D(t: any, tle1: any, tle2: any): void;
protected onViewChanged(): void;
isPicked(graphic: any): boolean;
/**
*
* @param event
* @param tle1
* @param tle2
* @param priod
*/
private listenerFun;
/**
*
*/
private changeRail;
/**
*
*/
destroyItem(): void;
/**
*
* @param val
* ```
*
* satellite.orbitColor='#ffffff';
* ```
*
*/
orbitColor: string;
/**
*
* @param val
* ```
*
* satellite.textColor='#ffff00';
* ```
*
*/
textColor: string;
/**
*
* @param val
* ```
*
* satellite.groundTrackColor='#ffffff'
* ```
*
*/
groundTrackColor: string;
/**
*
* @return {String}
* ```
*
* let name=satellite.name;
* ```
*
*/
readonly name: string;
/**
*
* @return {boolean}
* ```
*
* let isSyn = satellite.synchronous;
* ```
*
*/
readonly synchronous: boolean;
/**
*
* @readonly
* @type {number}
* @memberof Satellite
*/
readonly priod: number;
/**
*
* @return {GeoPoint}
*/
readonly position: GeoPoint;
/**
*
* @return {any}
*/
readonly satelliteSensor: any;
/**
* Km/s
* @type {number}
*/
readonly speed: number;
/**
*
*/
/**
*
*/
multiplier: number;
/**
*
* @memberof Satellite
*/
/**
*
* @type {Date}
* @memberof Satellite
*/
currentTime: Date;
/**
*
* @param localOrbitData
*/
setLocalOrbitData(localOrbitData: Array<GeoVector3>): void;
/**
*
* @readonly
* @memberof Satellite
*/
getPos(time: Date): GeoPoint;
/**
* multiplier
* @param number ,1
*/
clockMultiplier(value: number): void;
/**
*
*/
getLabelGraphic(): Cesium.LabelGraphics;
movePlay(flag: boolean): void;
}
class SatelliteOpt {
/**卫星两根数 */
tle: string;
/**轨道类型 */
orbitType?: SatelliteOrbitType;
/**轨道颜色 */
orbitColor?: string;
/**文本标签颜色 */
textColor?: string;
/**扫描锥颜色 */
coverColor?: string;
/**扫描带颜色 */
groundTrackColor?: string;
/**卫星罩类型 */
type?: StatelliteEnum;
/**卫星图标路径 */
imageUrl?: String;
/**轨道线宽度 */
orbitWidth?: number;
/**卫星模型url */
modelUrl?: string;
/**卫星模型占屏幕最小像素 */
sateMinPixelSize?: number;
/**本地轨道数据*/
localOrbitData: Array<GeoVector3>;
/**当前卫星时间 */
currentTime: Date;
/**是否为同步轨道卫星 */
synchronous: boolean;
/**同步卫星位置 */
synchronousPosition: GeoPoint;
constructor(tle: string, currentTime: Date, orbitType?: SatelliteOrbitType, orbitColor?: string, synchronous?: boolean, groundTrackColor?: string, type?: StatelliteEnum, orbitWidth?: number, imageUrl?: string, modelUrl?: string, sateMinPixelSize?: number, synchronousPosition?: GeoPoint, localOrbitData?: Array<GeoVector3>);
}
enum SatelliteOrbitType {
/**闭合圆轨道 */
'Eci' = 1,
/**非闭合圆轨道 */
'Ecf' = 2
}
/**
*
*/
enum StatelliteEnum {
/**圆锥罩 */
'conic' = 1,
/**棱锥罩 */
'square' = 2,
/**不规则多边形锥罩(同步卫星) */
'sync' = 3
}
/**
*
*/
class RectangularOpt {
/**水平开合角 */
xAngle: number;
/**垂直开合角 */
zAngle: number;
/**棱锥罩颜色 */
coverColor: string;
/**棱锥罩位置 */
rectangularPos: GeoPoint;
/**扫描版颜色 */
scanColor: string;
/**侧摆角 范围0-45度*/
swingAngle: number;
}
/**
*
*/
class ConicOpt {
/**圆锥罩开合角 */
conicAngle: number;
/**圆锥罩颜色 */
coverColor: string;
/**圆锥罩位置 */
conicPos: GeoPoint;
/**侧摆角 范围0-45度*/
swingAngle: number;
}
class SynchronousOpt {
/**同步卫星位置 */
position: GeoPoint;
/**覆盖范围顶点坐标 */
covers: GeoPoint[];
/**锥罩颜色 */
coverColor?: string;
}
class SatelliteComponents {
/**
*
*
*/
static readonly SatImage: string;
/**
*
*
*/
static readonly Label: string;
/**
*
*
*/
static readonly Orbit: string;
/**
* 线
*
*/
static readonly GroundTrack: string;
/**
*
*
*/
static readonly Sensor: string;
}
/**
* @类别 <br>
* @描述 <br>
* @see ../../../examples/gallery/editor.html#satalliteVis
*/
class SatelliteLayer extends Layer {
viewer: Cesium.Viewer;
constructor(viewer: Cesium.Viewer);
/**
*
* @return {Array}
*
*/
readonly satelliteNames: Array<any>;
/**
*
* @param item
*/
add(item: Item): Item;
/**
*
* @param {string}
*/
getSatellite(name: string): Item;
/**
*
* @param {number} x
* @param {number} y
* @return {Satellite}
*/
pickSatellite(x: number, y: number): Satellite;
/**
*
* @param
*/
remove(value: string | Satellite): Satellite;
/**
* json
* @param json
*/
parseJson(json: any): void;
/**
*
*/
clear(): void;
}
class SynchronousSensor {
private _opt;
private _primitiveCollection;
private _primitive;
private _groundPrimitive;
constructor(primitiveCollection: Cesium.PrimitiveCollection, opt: SynchronousOpt);
visible: boolean;
position: GeoPoint;
coverColor: any;
readonly primitive: Cesium.Primitive;
/**传感器覆盖范围(多边形 顶点)*/
readonly covers: GeoPoint[];
/**更新计算几何体 */
update(): void;
private createPrimitive;
private getMS;
private createGroundPrimitive;
destroy(): void;
}
class TargetFlame {
_target: any;
_init: boolean;
particleSystem: any;
emitterModelMatrix: Cesium.Matrix4;
translation: Cesium.Cartesian3;
rotation: Cesium.Quaternion;
hpr: Cesium.HeadingPitchRoll;
trs: Cesium.TranslationRotationScale;
_show: boolean;
_earth: any;
/**
* TargetItem
* @param id id
* @param lon
* @param lat
* @param alt
* @param smoothTrack
* ```
*
* let item = new GV.TargetItem('gb324244234sdf432',113.654,36.542.6921,true)
* ```
*/
constructor(target: any);
applyGravity(p: any, dt: any): void;
init(): void;
/**
*
* @method showTrack
*
* ```
*
* var show = targetItem.flame.show;
* targetItem.flame.show = true ;
* ```
*/
show: boolean;
updateFlame(): void;
computeEmitterModelMatrix(): Cesium.Matrix4;
dispose(): void;
}
enum TargetState {
Retain = 0,
Add = 1,
Update = 2,
Remove = 3,
None = 4
}
class TimePositions {
_init: boolean;
_positionList: Array<TimePosition>;
_positionIndex: number;
_sampleCount: number;
_sampleIndex: number;
_speed: number;
_cacheSize: number;
_positionScratch: Cesium.Cartesian3;
_target: any;
/**
* TargetItem
* @param id id
* @param lon
* @param lat
* @param alt
* @param smoothTrack
* ```
*
* let item = new GV.TargetItem('gb324244234sdf432',113.654,36.542.6921,true)
* ```
*/
constructor(target: any);
/**
*
* @method count
*
* ```
*
*
* ```
*/
readonly count: number;
/**
*
* @method addSample
* @param position
*
* ```
*
* ```
*/
addSample(position: TimePosition): void;
getMoveAmount(sPos: any, ePos: any): Cesium.Cartesian3;
getNearestIndex(time: any): number;
/**
*
* @method getHistoryPoints
*
* ```
* ```
*/
getHistoryPoints(): Array<TimePosition>;
/**
*
* @method getPreservePoints
*
* ```
* ```
*/
getPreservePoints(): Array<TimePosition>;
/**
*
* @method getPosition
*
* ```
*
* targetItem.getPosition(new Date());
* ```
*/
getPosition(time: any): Cesium.Cartesian3;
refreshList(): void;
/**
*
* @method speed
*
* ```
*
* var speed = targetItem.speed ;
* ```
*/
speed: number;
}
class TimePosition {
/**点位置 */
position: Cesium.Cartesian3;
/**时间点 */
time: number;
/**移动向量 */
timeSpan: number;
xSpan: number;
ySpan: number;
zSpan: number;
/**标记点是否是历史点 */
isHistory: boolean;
/**点索引号 */
index: number;
}
class WarningTargets {
private earth;
itemList: Map<any, any>;
graphicLayer: any;
constructor(viewer: GeoCanvas);
/**
*
* @method count
*/
readonly count: number;
/**
*
* @method addItem
* @param item
*/
addItem(item: TargetItem): void;
/**
*
* @method removeItem
* @param item
*/
removeItem(item: TargetItem): void;
/**
*
* @method updatePosition
* @param item
*/
updatePosition(item: TargetItem): void;
/**
*
* @method removeAll
*
*/
removeAll(): void;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#tsLayer.TargetHistory'></a>
*/
class TargetHistory {
private _historyDataSource;
private _dsName;
private _viewer;
private _entities;
private _trackLineColor;
private _trackLineWidth;
private _trackPointColor;
private _trackPointSize;
private _smoothTrack;
private _pathList;
private _computeAngle;
private _timePositionList;
/**
* TargetHistory
* @param viewer viewer对象
* ```
*
* var targetHistory = new GV.TargetHistory(viewer);
* ```
*/
constructor(viewer: any);
/**
* @ignore
*/
_timePosition2sample(timePostion: Array<number>): (any[] | Cesium.SampledPositionProperty)[];
addTargetHistoryEx(target: TargetItem, timePostion: Array<number>): void;
addEntitys(target: TargetItem): any[];
computeHeading(v1: any, v2: any): any;
/**
*
* @method addTargetHistory
*
* ```
*
* var itemTypecode = TargetHistory.addTargetHistory(target,[[113,36,500,1574906965962]]) ;
*
*
* ```
*/
addTargetHistory(target: TargetItem, timePostion: Array<number>): void;
/**
* 线
* @method removeAll
*
* ```
*
* TargetHistory.removeAll() ;
*
*
* ```
*/
removeAll(): void;
/**
* id删除轨迹线
* @method removeByID
*
* ```
*
* TargetHistory.removeByID('dfs') ;
*
*
* ```
*/
removeByID(id: any): void;
/**
*
* @method setTimeSection
*
* ```
*
* var itemTypecode = TargetHistory.setTimeSection(1574906965962,1574906969962) ;
*
* @returns {Boolean}
* ```
*/
setTimeSection(start: number, end: number): boolean;
/**
*
* @method speed
*
* ```
*
* var speed = TargetHistory.speed;
* TargetHistory.speed = 1.5;
*
*
* ```
*/
speed: number;
/**
* 沿线
* @method computeAngle
*
* ```
*
* var computeAngle = TargetHistory.computeAngle;
* TargetHistory.computeAngle = false;
*
*
* ```
*/
computeAngle: boolean;
/**
*
* @method animate
*
* ```
*
* var animate = TargetHistory.animate;
* TargetHistory.animate = true;
*
*
* ```
*/
animate: boolean;
/**
* 线
* @method show
*
* ```
*
* var show = targetHistory.show;
* targetHistory.show; = false ;
* ```
*/
show: boolean;
/**
* 线
* @method lineColor
*
* ```
*
* var color = targetHistory.lineColor;
* targetHistory.lineColor= Cesium.Color.fromRandom() ;
* ```
*/
lineColor: Cesium.Color;
/**
* 线
* @method lineWidth
*
* ```
*
* var width = targetHistory.lineWidth;
* targetHistory.lineWidth = 10 ;
* ```
*/
lineWidth: number;
/**
*
* @method pointColor
*
* ```
*
* var pointColor = targetHistory.pointColor;
* targetHistory.pointColor = Cesium.Color.fromRandom() ;
* ```
*/
pointColor: Cesium.Color;
/**
*
* @method pointSize
*
* ```
*
* var size = targetHistory.pointSize;
* targetHistory.pointSize = 10 ;
* ```
*/
pointSize: number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#dg_target.2321'>ts中的目标MBMB</a>
*/
class TargetItem extends Item {
_model: any;
_label: any;
_point: any;
_billbord: any;
protected _canvasLine: any;
protected _lineBillboard: any;
protected _data: any;
_position: Cesium.Cartesian3;
_geoPoint: GeoPoint;
protected _flag: TargetState;
protected _pedding: boolean;
_style: TargetStyle;
_timePosition: TimePositions;
protected _angle: number;
_parentLayer: any;
_init: boolean;
protected _type: string;
_smoothTrack: boolean;
protected _inview: boolean;
protected _timeArray: any[];
_bUseIconColor: boolean;
protected _time: string;
protected _speed: number;
protected _show: boolean;
protected _isSelected: boolean;
protected _showLabel: boolean;
_labelInit: boolean;
_linkLine: any;
protected _showLink: boolean;
protected _showModel: boolean;
protected _modelInit: boolean;
protected _backwardPath: any;
protected _forewardPath: any;
protected _flame: any;
protected _userHPR: any;
protected _color: any;
protected _modelColor: any;
protected _textColor: any;
protected _outlineColor: string;
protected _outlineWidth: number;
protected _itemtype: string;
protected _depthTest: boolean;
protected _partners: Map<any, any>;
/**
* TargetItem
* @param id id
* @param lon
* @param lat
* @param alt
* @param smoothTrack
* ```
*
* let item = new GV.TargetItem('gb324244234sdf432',113.654,36.542.6921,true)
* ```
*/
constructor(id: string, lon: number, lat: number, alt: number, smoothTrack?: boolean, showTrackLine?: boolean);
readonly timePositionList: TimePosition[];
/**
*
*/
getType(): string;
readonly forewardPath: TargetPath;
readonly backwardPath: TargetPath;
readonly flame: TargetFlame;
showLabel: boolean;
showModel: boolean;
/**
*
* @method styleCode
*
* ```
*
* var itemTypecode = targetItem.styleCode ;
* ```
*/
styleCode: string;
/**
*
* @method pointCacheSize
* @default 500
*
* ```
*
* targetItem.pointCacheSize = 1000 ;
* ```
*/
pointCacheSize: number;
/**
*
* @method flag
*
* ```
*
* var flag = targetItem.flag;
* ```
*/
flag: TargetState;
/**
*
*
* ```
*
* var position = targetItem.getPosition();
* ```
*/
getPosition(): Cesium.Cartesian3;
/**
*
* @method flag
*
* ```
*
* targetItem.useIconColor=false;
* ```
*/
useIconColor: boolean;
/**
*
* @method flag
*
* ```
*
* var show = targetItem.show;
* ```
*/
show: boolean;
/**
*
* @method smoothTrack
*
* ```
*
* var flag = targetItem.smoothTrack = true;
* ```
*/
smoothTrack: boolean;
/**
*
* @method style
*
* ```
*
* var style = targetItem.style;
* ```
*/
style: TargetStyle;
/**
*
* @method updatePosition
* @param lon
* @param lat
* @param alt
* @param delay ,
*
* ```
*
* targetItem.updatePosition(113.254,36.254,10000);
* targetItem.updatePosition(113.254,36.254,10000,10);
* ```
*/
updatePosition(lon: number, lat: number, alt: number, delay?: number): void;
getColor(): any;
/**
*
* @method name
*
* ```
*
* targetItem.name="RED";
* ```
*/
name: string;
/**
* ,css颜色值
* @method color
*
* ```
*
* targetItem.color="RED";
* targetItem.color="#FF0000";
* ```
*/
color: string;
/**
* ,css颜色值
* @method textColor
*
* ```
*
* targetItem.textColor="RED";
* targetItem.textColor="#FF0000";
* ```
*/
textColor: string;
/**
* ,css颜色值
* @method outlineColor
*
* ```
*
* targetItem.outlineColor="RED";
* targetItem.outlineColor="#FF0000";
* ```
*/
outlineColor: string;
/**
*
* @method outlineColor
*
* ```
*
* targetItem.outlineWidth=2;
* ```
*/
outlineWidth: number;
/**
*
* @method depthTest
*
* ```
*
* targetItem.depthTest=false;
* targetItem.outlineColor="#FF0000";
* ```
*/
depthTest: boolean;
/**
* ,css颜色值
* @method color
*
* ```
*
* targetItem.modelColor="RED";
* targetItem.modelColor="#FF0000";
* ```
*/
modelColor: string;
/**
*
* @method iconSize
*
* ```
*
* targetItem.iconSize=24;
* ```
*/
iconSize: number;
/**
*
* @method iconWidth
*
* ```
*
* targetItem.iconWidth=24;
* ```
*/
iconWidth: number;
/**
*
* @method iconHeight
*
* ```
*
* targetItem.iconHeight=24;
* ```
*/
iconHeight: number;
/**
*
* @method iconUrl
*
* ```
*
* targetItem.iconUrl='./test.png';
* ```
*/
iconUrl: string;
/**
*
* @method fontbgColor
*
* ```
*
* targetItem.fontbgColor='red';
* ```
*/
fontbgColor: string;
/**
*
* @method showFontbgColor
*
* ```
*
* targetItem.showFontbgColor = true;
* ```
*/
showFontbgColor: boolean;
/**
*
* @method isSelected
*
* ```
*
* targetItem.isSelected = true;
* ```
*/
isSelected: boolean;
/**
* 线
* @method showLink
*
* ```
*
* targetItem.showLink = true;
* ```
*/
showLink: boolean;
/**
*
* @method angle
*
* ```
*
* targetItem.angle=105;
* ```
*/
angle: number;
/**
* HeadingPitchRoll信息
* @method flag
*
* ```
*
* var hpr = targetItem.modelHPR;
* ```
*/
modelHPR: any;
/**
*
* @method time
*
* ```
*
* var time = targetItem.time ;
* ```
*/
time: string;
/**
*
* @method speed
*
* ```
*
* var speed = targetItem.speed ;
* ```
*/
speed: number;
/**************************伴飞对象接口************************ */
/**
*
* @method addPartner
* @param partner ,
* @returns
*
* ```
*/
addPartner(partner: any): any;
/**
*
* @method removePartner
* @param partner
* @returns
*
* ```
*/
removePartner(partner: any): any;
/**
*
* @method removeAllPartner
* @returns
*
* ```
*/
clearPartner(): void;
/**
*
* @method partnerList
* @returns
*/
readonly partnerList: Map<any, any>;
}
class TrackLineOption {
/**轨迹点个数 */
points: Array<Cesium.Cartesian3>;
/**轨迹线颜色 */
color: Cesium.Color;
/**轨迹线宽度 */
width: number;
/**轨迹点个数 */
count: number;
/**轨迹线是否可见 */
show: boolean;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#dg_target.2329'></a>
*/
class TargetLayer extends Layer {
private earth;
private renderOption;
private rootcollection;
private rootPointcollection;
private pointcollection;
private labelcollection;
private billbordcollection;
private modelcollection;
private trackLinecollection;
private trackPointcollection;
private targetCollection;
private defaultStyle;
private _show;
private _smoothTrack;
private targetdataSource;
private _gid;
private _ennableDrag;
private interplatePosition;
private showModel;
private displayCondition;
private anchorLine;
private linkLines;
layerConfig: Map<any, any>;
moveAmount: Cesium.Cartesian3;
positionScratch: Cesium.Cartesian3;
warningTargets: WarningTargets;
private _needUpdate;
private _linkLineWidth;
private _linkLineColor;
private _highlightSelection;
private _selectionColor;
private _brefresh;
private _canvasCache;
private _graphicGroup;
constructor(viewer: Cesium.Viewer);
readonly graphicGroup: any;
private _getUnderGoundExtent;
private _getCurrentExtent;
/**
* @ignore
*/
private _pointInView;
/**
* @ignore
*/
private _renderTarget;
/**
* @ignore
*/
private _getPoint;
/**
* @ignore
*/
private _getLable;
/**
* @ignore
*/
private _getBillboard;
/**
* @ignore
*/
private _getModel;
/**
* @ignore
*/
private _getLinkLine;
private _addTarget;
private addTrack;
/**
* @ignore
*/
private initMouseEvt;
private updateLineCanvas;
private loadLinklines;
/**
* @ignore
*
*/
private _addORUpdateTarget;
private getStyleByCode;
private setTargetStyle;
private updateLinkStyle;
/**
*
* @method pick
* @param x x
* @param y y
* @param clearSelection
*/
pick(x: number, y: number, clearSelection?: boolean): any;
/**
*
* @param x x
* @param y y
* @param width
* @param height
*/
pickRect(x: number, y: number, width: number, height: number): any[];
/**
*
* @method saveStyleConfig
* @return {Object}
*/
saveStyleConfig(): Object;
/**
*
* @method loadStyleConfig
* @param config
*/
loadStyleConfig(config: any): void;
/**
*
*/
highlightSelection: boolean;
/**
* highlightSelected true时
*/
selectionColor: string;
/**
*
*/
getSelection(): any[];
/**
*
*/
clearSelection(): void;
/**
*
*/
reverseSelection(): void;
/**
*
*/
selectAll(): void;
/**
*
*/
smoothTrack: boolean;
/**
*
*/
getItemList(): any[];
/**
* id
* @method id
* @readonly
* @return
*/
readonly id: string;
/**
*
* @method name
* @readonly
* @return
*/
readonly name: string;
/**
*
* @method ennableDrag
*/
ennableDrag: boolean;
/**
* 线
* @method linkLineWidth
*/
linkLineWidth: number;
/**
* 线
* @method linkLineColor
*/
linkLineColor: string;
/**
*
* @method isExist
* @param itemid ID
* @return
*/
isExist(itemid: string): boolean;
/**
*
* @method show
*
* ```
*
* targetLayer.show=false;
* ```
*/
show: boolean;
/**
*
* @method add
* @param item
* @return
*
* ```
*
* var tTarget = new GV.TargetItem("targetData.id",113.454,36.45,10000,0);
* targetLayer.add(tTarget);
*
* ```
*/
add(item: TargetItem): TargetItem;
/**
* id获取目标对象
* @method getItemById
* @param itemid id
* @return
*
* ```
*
* targetLayer.getItemById("targetData.id");
*
* ```
*/
getItemById(itemid: string): any;
/**
*
* @method remove
* @param itemid id
* @return
*
* ```
*
* targetLayer.remove("targetData.id");
*
* ```
*/
remove(value: string | TargetItem): TargetItem;
/**
*
* @method removeAll
* @return {Boolean}
*
* ```
*
* targetLayer.removeAll();
*
* ```
*/
removeAll(): boolean;
private refresh;
/**
*
*/
private destroy;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#dg_target.2326'>ts中的目标的各类轨迹绘制</a>
*/
class TargetPath {
private _target;
private _init;
private _trackLine;
private _trackPoints;
private _showTrack;
private _trackLineColor;
private _trackLineWidth;
private _trackPointColor;
private _trackPointSize;
private _trackPositionCount;
private _trackPositions;
private _trackInit;
private _trackLineType;
private _mtype;
private _backLineMode;
private _modeChange;
/**
* TargetPath
* @param target
* ```
*
* let itempath = new GV.TargetPath(target,)
* ```
*/
constructor(target: TargetItem, pType: any);
/**
*@ignore
*/
trackInit: boolean;
/**
*@ignore
*/
trackLine: any;
/**
*@ignore
*/
readonly mtype: PathType;
/**
*
* @method trackPositions
*
* ```
*
* var itemTypecode = targetItem.trackPositions ;
* ```
*/
readonly trackPositions: any[];
/**
*
* @method show
*
* ```
*
* var show = targetPath.show;
* targetPath.show = false ;
* ```
*/
show: boolean;
/**
* 线
* @method trackLineColor
*
* ```
*
* var color = targetPath.trackLineColor;
* targetPath.trackLineColor = Cesium.Color.fromRandom() ;
* ```
*/
trackLineColor: Cesium.Color;
/**
* 线
* @method trackLineCount
*
* ```
*
* var count = targetPath.trackPositionCount;
* targetPath.trackPositionCount = 10 ;
* ```
*/
trackPositionCount: number;
/**
* 线
* @method trackLineWidth
*
* ```
*
* var width = targetPath.trackLineWidth;
* targetPath.trackLineWidth = 10 ;
* ```
*/
trackLineWidth: number;
/**
*
* @method trackPointColor
*
* ```
*
* var width = targetPath.trackPointColor;
* targetPath.trackLineWidth = 10 ;
* ```
*/
trackPointColor: Cesium.Color;
/**
*
* @method trackPointSize
*
* ```
*
* var size = targetPath.trackPointSize;
* targetPath.trackLineWidth = 10 ;
* ```
*/
trackPointSize: number;
updateTrackPoint(): void;
/**
*
* @method getTrackPoint
*
* ```
*
* var point = targetPath.getTrackPoint(1) ;
* ```
*/
getTrackPoint(index: any): any;
/**
*
* @method trackLineType
*
* ```
*
* var trackLineType = targetPath.trackLineType ;
* ```
*/
trackLineType: string;
/**
* 线
* @method foreLineMode
*
* ```
*
* var foreLineMode = targetPath.foreLineMode;
* ```
*/
foreLineMode: BackLineMode;
updatePosition(position: Cesium.Cartesian3): void;
getTagPositions(): any[];
/**
* @ignore
*/
render(curentPosition: any): void;
}
class PathType {
/**未飞行轨迹 */
static backward: string;
/**历史轨迹 */
static foreward: string;
}
/**
* 线
*/
class BackLineMode {
/**渐变模式 */
static ramp: string;
/**全色模式 */
static full: string;
}
/**
* @类型 使
* @描述
*/
class TargetStyle {
private _color;
private _pointSize;
private _pointLineWidth;
private _pointLineColor;
private _pointDisplayCondition;
private _fontSize;
private _fontColor;
private _font;
private _fontbgColor;
private _showFontbgColor;
private _labelDisplayCondition;
private _labelLineColor;
private _iconUrl;
private _iconSize;
private _iconDisplayCondition;
private _modelUrl;
private _modelDisplayCondition;
private _modelMaximumScale;
private _modelMinimumPixelSize;
private _labeloffsetx;
private _labeloffsety;
private _trackLineWidth;
private _trackLineColor;
private _selectedColor;
private _showBackground;
_iconHeight: number;
_iconWidth: number;
constructor();
/**
*
* @method DefaultStyle
* @readonly
* @return
*/
static DefaultStyle(): TargetStyle;
/**
*
* @method color
* @return
*/
color: string;
/**
*
* @method showBackground
* @return
*/
showBackground: boolean;
/**
*
* @method selectedColor
* @return
*/
selectedColor: string;
/**
*
* @method pointSize
* @return
*/
pointSize: number;
/**
*
*/
pointLineWidth: number;
/**
*
*/
pointLineColor: string;
/**
*
*/
pointDisplayCondition: Cesium.DistanceDisplayCondition;
/**
*
*/
fontSize: number;
/**
*
*/
fontColor: string;
/**
*
*/
font: string;
/**
*
*/
fontbgColor: string;
/**
*
*/
showFontbgColor: boolean;
/**
*
*/
labelDisplayCondition: Cesium.DistanceDisplayCondition;
/**
* 线线
*/
labelLineColor: string;
/**
* ,使
*/
iconUrl: string;
/**
*
*/
iconSize: number;
iconDisplayCondition: Cesium.DistanceDisplayCondition;
/**
*
*/
modelUrl: string;
/**
*
*/
modelDisplayCondition: Cesium.DistanceDisplayCondition;
/**
*
*/
modelMaximumScale: number;
/**
*
*/
modelMinimumPixelSize: number;
/**
* 线
*/
trackLineWidth: number;
/**
* 线
*/
trackLineColor: string;
/**
* x轴偏移
*/
labeloffsetx: number;
/**
* y轴偏移
*/
labeloffsety: number;
/**
* json
* @method toJson
*
*/
static toJson(style: any): Object;
/**
*
* @method fromJson
* @param style
*
*/
static fromJson(style: any): TargetStyle;
}
abstract class ComTerrainProvider {
protected _heightmapWidth: number;
protected _heightmapStructure: any;
protected _ellipsoid: any;
protected _errorEvent: Cesium.Event;
protected _credit: Cesium.Credit;
protected _tileCredits: any[];
protected _availability: any;
protected _readyPromise: any;
protected _lastResource: any;
protected _layerJsonResource: any;
protected _metadataError: any;
protected _layers: any[];
protected _attribution: string;
protected _overallAvailability: any[];
protected _overallMaxZoom: any;
protected _tilingScheme: any;
protected _scheme: any;
protected _levelZeroMaximumGeometricError: any;
protected _hasMetadata: boolean;
protected _hasWaterMask: boolean;
protected _requestWaterMask: any;
protected _hasVertexNormals: boolean;
protected _requestVertexNormals: any;
protected _requestMetadata: any;
protected _ready: boolean;
constructor(opt: any);
private parseMetadataSuccess;
protected metadataSuccess(data: any): void;
private parseMetadataFailure;
protected metadataFailure(data: any): void;
protected requestLayerJson(): void;
private getAvailabilityTile;
protected checkLayer(provider: any, x: any, y: any, level: any, layer: any, topLayer: any): {
result: boolean;
promise?: undefined;
} | {
result: boolean;
promise: any;
};
protected getRequestHeader(extensionsList: any): {
Accept: string;
};
protected createQuantizedMeshTerrainData(provider: any, buffer: any, level: any, x: any, y: any, layer: any): any;
protected createHeightmapTerrainData(provider: any, buffer: any, level: any, x: any, y: any): any;
requestTileGeometry(x: any, y: any, level: any, request: any): any;
protected requestTile(provider: any, x: any, y: any, level: any, layerToUse: any, request: any): any;
getTileDataAvailable(x: any, y: any, level: any): boolean;
/**
* Gets the maximum geometric error allowed in a tile at a given level.
*
* @param {Number} level The tile level for which to get the maximum geometric error.
* @returns {Number} The maximum geometric error.
*/
getLevelMaximumGeometricError(level: any): number;
/**
* Gets an event that is raised when the terrain provider encounters an asynchronous error. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof CesiumTerrainProvider.prototype
* @type {Event}
*/
readonly errorEvent: Cesium.Event;
/**
* Gets the credit to display when this terrain provider is active. Typically this is used to credit
* the source of the terrain. This function should not be called before {@link CesiumTerrainProvider#ready} returns true.
* @memberof CesiumTerrainProvider.prototype
* @type {Credit}
*/
readonly credit: Cesium.Credit;
/**
* Gets the tiling scheme used by this provider. This function should
* not be called before {@link CesiumTerrainProvider#ready} returns true.
* @memberof CesiumTerrainProvider.prototype
* @type {GeographicTilingScheme}
*/
readonly tilingScheme: any;
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof CesiumTerrainProvider.prototype
* @type {Boolean}
*/
readonly ready: boolean;
/**
* Gets a promise that resolves to true when the provider is ready for use.
* @memberof CesiumTerrainProvider.prototype
* @type {Promise.<Boolean>}
* @readonly
*/
readonly readyPromise: any;
/**
* Gets a value indicating whether or not the provider includes a water mask. The water mask
* indicates which areas of the globe are water rather than land, so they can be rendered
* as a reflective surface with animated waves. This function should not be
* called before {@link CesiumTerrainProvider#ready} returns true.
* @memberof CesiumTerrainProvider.prototype
* @type {Boolean}
* @exception {DeveloperError} This property must not be called before {@link CesiumTerrainProvider#ready}
*/
readonly hasWaterMask: any;
/**
* Gets a value indicating whether or not the requested tiles include vertex normals.
* This function should not be called before {@link CesiumTerrainProvider#ready} returns true.
* @memberof CesiumTerrainProvider.prototype
* @type {Boolean}
* @exception {DeveloperError} This property must not be called before {@link CesiumTerrainProvider#ready}
*/
readonly hasVertexNormals: any;
/**
* Gets a value indicating whether or not the requested tiles include metadata.
* This function should not be called before {@link CesiumTerrainProvider#ready} returns true.
* @memberof CesiumTerrainProvider.prototype
* @type {Boolean}
* @exception {DeveloperError} This property must not be called before {@link CesiumTerrainProvider#ready}
*/
readonly hasMetadata: any;
/**
* Boolean flag that indicates if the client should request vertex normals from the server.
* Vertex normals data is appended to the standard tile mesh data only if the client requests the vertex normals and
* if the server provides vertex normals.
* @memberof CesiumTerrainProvider.prototype
* @type {Boolean}
*/
readonly requestVertexNormals: any;
/**
* Boolean flag that indicates if the client should request a watermask from the server.
* Watermask data is appended to the standard tile mesh data only if the client requests the watermask and
* if the server provides a watermask.
* @memberof CesiumTerrainProvider.prototype
* @type {Boolean}
*/
readonly requestWaterMask: any;
/**
* Boolean flag that indicates if the client should request metadata from the server.
* Metadata is appended to the standard tile mesh data only if the client requests the metadata and
* if the server provides a metadata.
* @memberof CesiumTerrainProvider.prototype
* @type {Boolean}
*/
readonly requestMetadata: any;
/**
* Gets an object that can be used to determine availability of terrain from this provider, such as
* at points and in rectangles. This function should not be called before
* {@link CesiumTerrainProvider#ready} returns true. This property may be undefined if availability
* information is not available. Note that this reflects tiles that are known to be available currently.
* Additional tiles may be discovered to be available in the future, e.g. if availability information
* exists deeper in the tree rather than it all being discoverable at the root. However, a tile that
* is available now will not become unavailable in the future.
* @memberof CesiumTerrainProvider.prototype
* @type {TileAvailability}
*/
readonly availability: any;
}
class LayerInfo {
resource: any;
version: any;
isHeightmap: any;
tileUrlTemplates: any;
availability: any;
hasVertexNormals: any;
hasWaterMask: any;
hasMetadata: any;
availabilityLevels: any;
availabilityTilesLoaded: any;
littleEndianExtensionSize: any;
availabilityPromiseCache: any;
constructor(layer: any);
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#multi-Terrain'></a>
*/
class TerrainItem extends Item {
private _show;
private _index;
private _terrainProvider;
protected _type: string;
constructor(terrainProvider: any, option: any);
/**
*
* @method show
*
* ```
*
* terrainLayer.show=false;
* ```
*/
show: boolean;
readonly terrainProvider: any;
/**
*
* @method index
*
* ```
*
* terrainLayer.index=10;
* ```
*/
index: number;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
toJson(): object;
/**
* json对象
*/
parseJson(json: object): void;
/**
*
*/
private destroy;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#multi-Terrain'></a>
*/
class TerrainLayerCollection extends Layer {
private earth;
private _terrainLayers;
private _show;
private _baseProvider;
constructor(viewer: Cesium.Viewer);
/**
* @ignore
*/
_initBaseTerrain(): void;
/**
* @ignore
*/
_getTerrainData(x: any, y: any, level: any, request: any): any;
/**
* @ignore
*/
_reloadTerain(): void;
/**
*
* @method show
*
* ```
*
* terrainLayer.show=false;
* ```
*/
show: boolean;
/**
*
* @method add
* @param item
* @return
*
* ```
*
* var terrainItem = new GV.createWorldTerrain();
* terrainLayer.add(terrainItem);
*
* ```
*/
add(item: any): TerrainItem;
/**
* id获得对象
* @param itemid id
*/
getItemById(itemid: string): TerrainItem;
/**
* name获得对象
* @param itemName
*/
getItemByName(itemName: string): any;
/**
*
* @method remove
* @param itemid id
* @return
*
* ```
*
* terrainLayer.remove("id");
*
* ```
*/
remove(itemid: string): any;
/**
*
* @method removeAll
* @return {Boolean}
*
* ```
*
* terrainLayer.removeAll();
*
* ```
*/
removeAll(): void;
/**
*
*/
private destroy;
}
class TMSTerrainProvider extends ComTerrainProvider {
private _tileSets;
private _width;
private _height;
private _dataFormat;
private _dataExtension;
constructor(opt: any);
protected xmlSuccess(xmlDoc: any): void;
protected xmlFailure(data: any): void;
protected requestLayerXml(): void;
private getLevelUrl;
protected requestTile(provider: any, x: any, y: any, level: any, layerToUse: any, request: any): any;
/**
* buffer
* @param image
* @param heightBuffer buffer
*/
protected getImagePixels(image: any, heightBuffer: any): void;
/**
*
* @param tileBuffer
* @param heightBuffer
*/
private getRightPixels;
/**
*
* @param tileBuffer
* @param heightBuffer
*/
private getBottomPixels;
/**
*
* @param tileBuffer
* @param heightBuffer
*/
private getRightBottomPixel;
protected requestTileBuffer(url: any, version: any, level: any, x: any, y: any, query: any, headers: any, request: any): any;
private getPixelIndex;
/**
* QuantizedMesh地形瓦片
* @param provider
* @param buffer
* @param level
* @param x
* @param y
* @param layer
*/
protected createQuantizedMeshTerrainData__(provider: any, buffer: any, level: any, x: any, y: any): any;
private createHeightmap;
/**
* true(); false(); undefined(provider不支持这个瓦片)
* @param x
* @param y
* @param level
*/
getTileDataAvailable(x: any, y: any, level: any): boolean;
}
/**
* @类别 <br>
* @描述
* @see <a href='../../../examples/gallery/editor.html#BDTileLayer'></a>
*/
class BDTileLayer extends Item {
protected _name: any;
protected _changed: Cesium.Event;
protected _error: Cesium.Event;
protected _loading: Cesium.Event;
protected _isLoading: boolean;
protected _scene: any;
protected _loaded: boolean;
protected _tileReplacementQueue: any;
protected _tileCacheSize: any;
protected _renderTiles: Cesium.AssociativeArray;
protected _maxLevel: any;
protected _showLevel: any;
protected _deleteTileSetEvent: Cesium.Event;
protected _pickEvent: Cesium.Event;
protected _geographicTilingScheme: Cesium.GeographicTilingScheme;
protected _maxmemory: any;
protected _url: any;
protected _show: boolean;
protected _viewer: GeoCanvas;
protected _id: string;
/**
*
* @param {string} url
* @param {number} showLevel >=0 && <=22
* @returns
* ```
*
* let gridLayer = new GV.BDTileLayer(urlService, 9);
* viewer.tileLayer.add(gridLayer);
* ```
*/
constructor(url: string, showLevel?: number);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @param {GeoCanvas} viewer
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
name: any;
private show;
private findTileFromCache;
private tilesetDeletechange;
private processTile;
getTileExtent(tile: any): {
xmin: number;
xmax: number;
ymin: number;
ymax: number;
};
private buildTileUrl;
private getRenderTileKeys;
private update;
private destroy;
}
/**
* @类型 GeoSotLayer网格图层
* @描述
* @see <a href='../../../examples/gallery/editor.html#GeoSotLayer'></a>
*/
class GeoSotLayer {
private viewer;
private labels;
private colseRangeLabels;
private _visible;
private primitive;
private _url;
private _removeEnd;
private _entity;
private _currenInfo;
private _enablePick;
private _currentGrid;
private _queryUrl;
private _currentLevel;
private _is3D;
private _primitive3D;
private _gridColor;
private _fillColor;
private _isClip;
private _clipExt;
private _clipEntity;
constructor(viewer: Cesium.Viewer, url: string);
private pickEvent;
/**
*
* @memberof MapSheet
*/
visible: boolean;
/**
*
* @memberof MapSheet
*/
enablePick: boolean;
/**
* Url
* @memberof MapSheet
*/
queryUrl: boolean;
/**
*
*/
private remove;
/**
*
*/
private addExtent;
/**
* 线label进入场景
* @param data
*/
private getData;
/**
* 线label进入场景
* @param data
*/
private updatePrimitive;
/**
* 线label进入场景
* @param data
*/
private updatePrimitive3D;
setClipRange(xmin: any, ymin: any, xmax: any, ymax: any, bottom?: number, top?: number): void;
clearClipRange(): void;
destroy(): void;
}
/**
* @类别 <br>
* @描述
* @see <a href='../../../examples/gallery/editor.html#iconTile'></a>
*/
class IconTile extends Item {
protected _imageUrl: string;
protected _scale: number;
protected _provider: WMTSVectorProvider;
protected _name: any;
protected _tileCacheSize: any;
protected _renderTiles: any;
protected _pickInstance: any;
protected _pickTile: any;
protected _tileReplacementQueue: any;
protected _entityCluster: Cesium.EntityCluster;
protected _entityCollection: Cesium.EntityCollection;
protected _pickEvent: Cesium.Event;
protected _loading: Cesium.Event;
protected _error: Cesium.Event;
protected _changed: Cesium.Event;
protected _isLoading: boolean;
protected _isPick: any;
protected _maxLevel: any;
protected _minLevel: any;
protected _loaded: boolean;
protected _pickPrimitive: Cesium.ScreenSpaceEventHandler;
protected _oldInstance: any;
protected _scene: any;
private _viewer;
protected _pickedColor: string;
protected _id: string;
/**
*
* @param options
* @returns
* ```
*
* let iconTileOpt = new GV.IconTileOpt(urlService, layer);
* let iconTile = new GV.IconTile(iconTileOpt);
* viewer.tileLayer.add(iconTile);
* ```
*/
constructor(options: IconTileOpt);
/**
*
* @param {GeoCanvas}
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @param {Function} callback
* ```
*
* iconTile.onPick = onPickChanged;
* function onPickChanged(instance) {
* console.log(instance);
* }
* ```
*/
onPick: Function;
/**
*
*/
destroyItem(): void;
/**
*
* @memberof IconTileDataSource
*/
/**
*
* @memberof IconTileDataSource
*/
name: any;
/**
*
* @memberof IconTileDataSource
*/
private readonly clock;
/**
*
* @memberof IconTileDataSource
*/
private readonly entities;
/**
*
* @memberof IconTileDataSource
*/
private readonly isLoading;
/**
*
* @memberof IconTileDataSource
*/
private readonly changedEvent;
/**
*
* @memberof IconTileDataSource
*/
private readonly pickEvent;
/**
*
* @memberof IconTileDataSource
*/
private readonly errorEvent;
/**
*
* @memberof IconTileDataSource
*/
private readonly loadingEvent;
/**
*
* @memberof IconTileDataSource
*/
/**
*
* @memberof IconTileDataSource
*/
private show;
/**
*
* @memberof IconTileDataSource
*/
/**
*
* @memberof IconTileDataSource
*/
private clustering;
/**
* @private
* @memberof IconTileDataSource
*/
private findTileFromCache;
/**
* @private
* @memberof IconTileDataSource
*/
private handleParentAndChildren;
/**
* @private 广
* @memberof IconTileDataSource
*/
private createBill;
/**
* @private
* @memberof IconTileDataSource
*/
private processBill;
/**
* @private
* @memberof IconTileDataSource
*/
private processFeature;
/**
* @private
* @memberof IconTileDataSource
*/
private loadBillData;
/**
* @private
* @memberof IconTileDataSource
*/
private processTile;
/**
* @private Key值
* @memberof IconTileDataSource
*/
private getRenderTileKeys;
/**
* @private
* @memberof IconTileDataSource
*/
private update;
/**
* @private
* @memberof IconTileDataSource
*/
private destroy;
}
/**
*
* icenter配合的特定功能url当前对外呈现的是wmts的方式接入wms等
*/
class IconTileOpt {
/**服务地址 */
url: string;
/**图层信息 */
layer: string;
/**图标路径 */
imageUrl: string;
/**数据显示最小层级 (范围:>=0 && <=22*/
minLevel: number;
/**数据显示最大层级 (范围:>=0 && <=22*/
maxLevel: number;
/**是否开启选中功能 */
isPick: boolean;
/**被选中颜色 */
pickedColor: string;
/**图标缩放系数 (范围:>=0 && <=10*/
scale: number;
constructor(url: string, layer: string, imageUrl?: string, minLevel?: number, maxLevel?: number, isPick?: boolean, pickedColor?: string, scale?: number);
}
class GxGeoRegion {
MinX: any;
MaxX: any;
MinY: any;
MaxY: any;
MinLon: any;
MaxLon: any;
MinLat: any;
MaxLat: any;
readonly CenterX: number;
readonly CenterY: number;
readonly XSpan: number;
readonly YSpan: number;
readonly CenterLon: number;
readonly CenterLat: number;
}
class JPlaceNameTile {
static CurrentLV: number;
static CurrentPlaceName: Placename[];
LayerStyles: Map<number, LayerStyle>;
private viewer;
private labelCollection;
private billboardcollection;
rootcollection: Cesium.PrimitiveCollection;
InitViewer(viewer: Cesium.Viewer): void;
show: boolean;
load(data: Array<Placename>, clear: boolean): void;
static borderColor: string;
static getPlaceLabelParam(bm: number): [number, string, string];
}
class LayerStyle {
FontName: string;
FontSize: number;
FontColor: number;
FontBolderColor: number;
ImageDisplay: boolean;
ImageString: string;
FontA: number;
FontR: number;
FontG: number;
FontB: number;
BorderA: number;
BorderR: number;
BorderG: number;
BorderB: number;
}
class Placename {
DMBS: number;
DMCJBM: number;
DMMC: string;
WZ: string;
MS: string;
DLBM: number;
DMMCCD: number;
DMJP: string;
DMQP: string;
DMBM: string;
BDY: string;
YWMC: string;
DMDZ: string;
DMGC: number;
LV: number;
readonly LocStr: string;
}
/**
* J地名服务对接
* J地名服务对接
*/
class PlaceNameService {
private baseurl;
private collection;
private LayerStyles;
private viewer;
private _visible;
/**
*
* @param value
*/
/**
*
*/
visible: boolean;
/**
*
* @param viewer
* @param url
*/
constructor(viewer: Cesium.Viewer, url?: string);
private initPlaceNameStyle;
/**
*
*/
private showPlaceName;
private oldgeocoord;
private onCameraChange;
private readonly DegreeToRadians;
private GetTileList;
private CaculateTile;
private getJSON;
private getCurrentExtent;
}
class QRTile {
Level: any;
Row: any;
Col: any;
constructor(level: any, row: any, col: any);
addPreZero(num: number): string;
Code(): string;
}
class ViewerSceen {
xmin: number;
ymin: number;
xmax: number;
ymax: number;
height: number;
}
/**
* @类别 <br>
* @描述
* @see <a href='../../../examples/gallery/editor.html#placename'></a>
*/
class JQPlaceNameTile extends Item {
protected _name: any;
protected _changed: Cesium.Event;
protected _error: Cesium.Event;
protected _isLoading: boolean;
protected _loading: Cesium.Event;
protected _entityCluster: Cesium.EntityCluster;
protected _entityCollection: Cesium.EntityCollection;
protected _url: any;
protected _scene: any;
private _viewer;
protected _tileReplacementQueue: any;
protected _tileCacheSize: any;
protected _renderTiles: Cesium.AssociativeArray;
protected _clusterDirty: number;
protected _table: Map<any, any>;
protected _styleTable: any;
protected _currentTiles: any[];
protected _id: string;
protected _tilingScheme: any;
protected _placeNameImagery: any;
protected _timer: any;
/**
*
* @param options
* @returns
* ```
*
* let PlaceNameTileOpt = new GV.JQPlaceNameTileOpt(urlService);
* let placeNameTile = new GV.JQPlaceNameTile(PlaceNameTileOpt);
* viewer.tileLayer.add(placeNameTile);
* ```
*/
constructor(options: JQPlaceNameTileOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @param {GeoCanvas}
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
private createLevelMap;
private createDefaultStyles;
/**
* .
* @memberof PlaceTileDataSource.prototype
* @type {Boolean}
*/
private show;
/**
* Gets or sets the clustering options for this data source. This object can be shared between multiple data sources.
*
* @memberof PlaceTileDataSource.prototype
* @type {EntityCluster}
*/
private clustering;
private createTileKey;
private processTile;
private update;
private doUpdate;
private getX;
private getY;
private cluster;
private destroy;
}
/**
*
*/
class JQPlaceNameTileOpt {
/**服务地址 */
url: string;
/**投影方式 */
tilingScheme: Cesium.WebMercatorTilingScheme;
/**级别映射 */
table: Map<number, Array<number>>;
/**样式 */
styles: Map<number, Array<JQPlaceFontStyle>>;
constructor(url: string, table?: Map<number, Array<number>>, styles?: Map<number, Array<JQPlaceFontStyle>>);
}
/**
*
*/
class JQPlaceFontStyle {
/**字体、大小 */
font: string;
/**字体颜色 */
fillColor: string;
/**外边框颜色 */
outlineColor: string;
/**外边框宽度 */
outlineWidth: number;
constructor(font?: string, fillColor?: string, outlineColor?: string, outlineWidth?: number);
}
class PlacenameWrraper {
constructor(options: any);
static getPlaceList(arrayBuffer: any): any[];
}
/**
*@ignore
*/
class placeNameImageryProvider {
_tilingScheme: Cesium.WebMercatorTilingScheme;
_tileWidth: number;
_tileHeight: number;
_readyPromise: any;
_maximumLevel: number;
_minimumLevel: number;
_requestImage: any;
constructor(options: any);
readonly tileWidth: number;
readonly tileHeight: number;
readonly maximumLevel: number;
readonly minimumLevel: number;
readonly tilingScheme: Cesium.WebMercatorTilingScheme;
readonly rectangle: Cesium.Rectangle;
readonly ready: boolean;
readonly readyPromise: any;
readonly hasAlphaChannel: boolean;
requestImage: any;
}
/**
* @类别 <br>
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#vectorDisplay'>线</a>
*/
class LineTile extends Item {
protected _id: string;
protected _name: any;
protected _changed: any;
protected _error: any;
protected _isLoading: boolean;
protected _loading: any;
protected _entityCollection: any;
protected _entityCluster: any;
protected _scene: any;
protected _provider: any;
protected _loaded: boolean;
protected _options: any;
protected _tileReplacementQueue: any;
protected _tileCacheSize: any;
protected _minLevel: any;
protected _renderTiles: any;
protected _maxLevel: any;
protected _pickEvent: any;
protected _oldTile: any;
protected _isBuilding: any;
protected _pickShow: any;
protected _pickType: any;
protected _pickPrimitive: any;
protected _viewer: GeoCanvas;
/**
*
* @param options
* @returns
* ```
*
* let lineTileOpt = new GV.LineTileOpt(urlService, layer);
* let lineTile = new GV.LineTile(lineTileOpt);
* viewer.tileLayer.add(lineTile);
* ```
*/
constructor(options: LineTileOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
private coordinatesArrayToCartesianArray;
private createLineString;
private processLineString;
private processMultiLineString;
private createPolygon;
private processPolygon;
private processMultiPolygon;
private processFeature;
private processFeatureCollection;
private defaultCrsFunction;
/**
*
* @param {GeoCanvas} viewer
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
/**
*
* @param {Function} callback
*/
onPick: Function;
/**
* Gets an object that maps the name of a crs to a callback function which takes a GeoJSON coordinate
* and transforms it into a WGS84 Earth-fixed Cartesian. Older versions of GeoJSON which
* supported the EPSG type can be added to this list as well, by specifying the complete EPSG name,
* for example 'EPSG:4326'.
* @memberof GeoJsonDataSource
* @type {Object}
*/
private readonly crsNames;
/**
* Gets or sets a human-readable name for this instance.
* @memberof VectorTileDataSource.prototype
* @type {String}
*/
name: any;
private readonly clock;
/**
* Gets the collection of {@link Entity} instances.
* @memberof VectorTileDataSource.prototype
* @type {EntityCollection}
*/
private readonly entities;
/**
* Gets a value indicating if the data source is currently loading data.
* @memberof VectorTileDataSource.prototype
* @type {Boolean}
*/
private readonly isLoading;
/**
* Gets an event that will be raised when the underlying data changes.
* @memberof GeoJsonDataSource.prototype
* @type {Event}
*/
private readonly changedEvent;
/**
* Gets an event that will be raised when pick rendered object.
* @memberof VectorTileDataSource.prototype
* @type {Event}
*/
private readonly pickEvent;
/**
* Gets an event that will be raised if an error is encountered during processing.
* @memberof VectorTileDataSource.prototype
* @type {Event}
*/
private readonly errorEvent;
/**
* Gets an event that will be raised when the data source either starts or stops loading.
* @memberof VectorTileDataSource.prototype
* @type {Event}
*/
private readonly loadingEvent;
/**
* Gets whether or not this data source should be displayed.
* @memberof VectorTileDataSource.prototype
* @type {Boolean}
*/
private show;
/**
* Gets or sets the clustering options for this data source. This object can be shared between multiple data sources.
*
* @memberof VectorTileDataSource.prototype
* @type {EntityCluster}
*/
private clustering;
private pickAllTileProperty;
private findTileFromCache;
private findParentAndChildren;
private handleParentAndChildren;
private processTile;
private getRenderTileKeys;
private update;
private destroy;
}
/**
*
* icenter配合的特定功能url当前对外呈现的是wmts的方式接入wms等
*/
class LineTileOpt {
/**服务地址 */
url: string;
/**图层信息 */
layer: string;
/**wmts中对应的<TileMatrixSet>节点下面的<ows:Identifier>属性信息 */
tilematrixset: string;
/**格式 'application/json;type=geojson'或者'application/x-protobuf;type=mapbox-vector'*/
format: string;
/**线颜色 */
lineColor: string;
/**线宽 */
strokeWidth: Number;
/**显示的最小层级 (范围:>=0 && <=22*/
minLevel: number;
/**显示的最大层级 (范围:>=0 && <=22*/
maxLevel: number;
/**是否选中 */
isPick: boolean;
/**选中颜色 */
pickedColor: string;
constructor(url: string, layer: string, lineColor?: string, strokeWidth?: number, minLevel?: number, maxLevel?: number, isPick?: boolean, pickedColor?: string);
}
/**
* @类别 <br>
* @描述
* @see <a href='../../../examples/gallery/editor.html#big3dTile'></a>
*/
class ObliqueTile extends Item {
protected _name: any;
protected _changed: Cesium.Event;
protected _error: Cesium.Event;
protected _loading: Cesium.Event;
protected _isLoading: boolean;
protected _entityCollection: Cesium.EntityCollection;
protected _entityCluster: Cesium.EntityCluster;
protected _scene: any;
protected _loaded: boolean;
protected _tileReplacementQueue: any;
protected _tileCacheSize: any;
protected _renderTiles: Cesium.AssociativeArray;
protected _maxLevel: any;
protected _showLevel: any;
protected _deleteTileSetEvent: Cesium.Event;
protected _pickEvent: Cesium.Event;
protected _vectorLevel: any;
protected _maximumScreenSpaceError: any;
protected _maxmemory: any;
protected _url: any;
protected _bArea: any;
protected _minX: any;
protected _minY: any;
protected _maxX: any;
protected _maxY: any;
protected _viewer: GeoCanvas;
protected _id: string;
/**
*
* @param {string} url
* @param {number} vectorLevel >=0 && <=22
* @param {number} showLevel >=0 && <=22
* @param {number} maxscreenerror >4 && <=512
* @param {number} maxmemory >256 && <=2048
* @returns
* ```
*
* let oblique = new GV.ObliqueTile(urlService, 13, 161281024);
* viewer.tileLayer.add(oblique);
* ```
*/
constructor(url: string, vectorLevel?: number, showLevel?: number, maxscreenerror?: number, maxmemory?: number);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @param {GeoCanvas} viewer
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
/**
* Gets an object that maps the name of a crs to a callback function which takes a GeoJSON coordinate
* and transforms it into a WGS84 Earth-fixed Cartesian. Older versions of GeoJSON which
* supported the EPSG type can be added to this list as well, by specifying the complete EPSG name,
* for example 'EPSG:4326'.
* @memberof GeoJsonDataSource
* @type {Object}
*/
private readonly crsNames;
/**
* Gets an object that maps the href property of a crs link to a callback function
* which takes the crs properties object and returns a Promise that resolves
* to a function that takes a GeoJSON coordinate and transforms it into a WGS84 Earth-fixed Cartesian.
* Items in this object take precedence over those defined in <code>crsLinkHrefs</code>, assuming
* the link has a type specified.
* @memberof GeoJsonDataSource
* @type {Object}
*/
private readonly crsLinkHrefs;
/**
* Gets an object that maps the type property of a crs link to a callback function
* which takes the crs properties object and returns a Promise that resolves
* to a function that takes a GeoJSON coordinate and transforms it into a WGS84 Earth-fixed Cartesian.
* Items in <code>crsLinkHrefs</code> take precedence over this object.
* @memberof GeoJsonDataSource
* @type {Object}
*/
private readonly crsLinkTypes;
/**
* Gets or sets a human-readable name for this instance.
* @memberof ObliqueTileDataSource.prototype
* @type {String}
*/
name: any;
private readonly clock;
/**
* Gets the collection of {@link Entity} instances.
* @memberof ObliqueTileDataSource.prototype
* @type {EntityCollection}
*/
private readonly entities;
/**
* Gets a value indicating if the data source is currently loading data.
* @memberof ObliqueTileDataSource.prototype
* @type {Boolean}
*/
private readonly isLoading;
/**
* Gets an event that will be raised when the underlying data changes.
* @memberof GeoJsonDataSource.prototype
* @type {Event}
*/
private readonly changedEvent;
/**
* Gets an event that will be raised when pick rendered object.
* @memberof ObliqueTileDataSource.prototype
* @type {Event}
*/
private readonly pickEvent;
/**
* Gets an event that will be raised if an error is encountered during processing.
* @memberof ObliqueTileDataSource.prototype
* @type {Event}
*/
private readonly errorEvent;
/**
* Gets an event that will be raised when the data source either starts or stops loading.
* @memberof ObliqueTileDataSource.prototype
* @type {Event}
*/
private readonly loadingEvent;
/**
* Gets whether or not this data source should be displayed.
* @memberof ObliqueTileDataSource.prototype
* @type {Boolean}
*/
private show;
/**
* Gets or sets the clustering options for this data source. This object can be shared between multiple data sources.
*
* @memberof ObliqueTileDataSource.prototype
* @type {EntityCluster}
*/
private clustering;
private findTileFromCache;
private tilesetDeletechange;
private getParentKey;
private processTile;
private getRenderTileKeys;
private update;
private destroy;
}
/**
* @类别 Cesium扩展类<br>
* @描述
* @see <a href='../../../examples/gallery/editor.html#placename'></a>
*/
class PlaceNameTile extends Item {
protected _name: any;
protected _changed: Cesium.Event;
protected _error: Cesium.Event;
protected _isLoading: boolean;
protected _loading: Cesium.Event;
protected _entityCluster: Cesium.EntityCluster;
protected _entityCollection: Cesium.EntityCollection;
protected _url: any;
protected _scene: any;
private _viewer;
protected _tileReplacementQueue: any;
protected _tileCacheSize: any;
protected _renderTiles: Cesium.AssociativeArray;
protected _clusterDirty: number;
protected _table: Map<any, any>;
protected _styleTable: any;
protected _id: string;
/**
*
* @param options
* @returns
* ```
*
* let PlaceNameTileOpt = new GV.PlaceNameTileOpt(urlService);
* let placeNameTile = new GV.PlaceNameTile(PlaceNameTileOpt);
* viewer.tileLayer.add(placeNameTile);
* ```
*/
constructor(options: PlaceNameTileOpt);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @param {GeoCanvas}
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
private createLevelMap;
private createDefaultStyles;
/**
* Gets or sets a human-readable name for this instance.
* @memberof PlaceTileDataSource.prototype
* @type {String}
*/
private readonly clock;
/**
* Gets the collection of {@link Entity} instances.
* @memberof PlaceTileDataSource.prototype
* @type {EntityCollection}
*/
private readonly entities;
/**
* Gets a value indicating if the data source is currently loading data.
* @memberof PlaceTileDataSource.prototype
* @type {Boolean}
*/
private readonly isLoading;
/**
* Gets an event that will be raised when the underlying data changes.
* @memberof PlaceTileDataSource.prototype
* @type {Event}
*/
private readonly changedEvent;
/**
* Gets an event that will be raised if an error is encountered during processing.
* @memberof PlaceTileDataSource.prototype
* @type {Event}
*/
private readonly errorEvent;
/**
* Gets an event that will be raised when the data source either starts or stops loading.
* @memberof PlaceTileDataSource.prototype
* @type {Event}
*/
private readonly loadingEvent;
/**
* Gets whether or not this data source should be displayed.
* @memberof PlaceTileDataSource.prototype
* @type {Boolean}
*/
private show;
/**
* Gets or sets the clustering options for this data source. This object can be shared between multiple data sources.
*
* @memberof PlaceTileDataSource.prototype
* @type {EntityCluster}
*/
private clustering;
private createTileKey;
private getSubTileKeys;
private getTiles;
private calculateTiles;
private getGeoCode;
private processTile;
private _control;
doOriginTiles(): void;
doPlaceTiles(): void;
doCreateTiles(): void;
doRequestTile(tile: any): any;
doAnalysis(tile: any): void;
doRender(tile: any): void;
doProcess(): void;
private _clusterCount;
private update;
private getX;
private getY;
private cluster;
private destroy;
}
/**
*
*/
class PlaceNameTileOpt {
/**服务地址 */
url: string;
/**级别映射 */
table: Map<number, Array<number>>;
/**样式 */
styles: Map<number, Array<PlaceFontStyle>>;
constructor(url: string, table?: Map<number, Array<number>>, styles?: Map<number, Array<PlaceFontStyle>>);
}
/**
*
*/
class PlaceFontStyle {
/**字体、大小 */
font: string;
/**字体颜色 */
fillColor: string;
/**外边框颜色 */
outlineColor: string;
/**外边框宽度 */
outlineWidth: number;
constructor(font?: string, fillColor?: string, outlineColor?: string, outlineWidth?: number);
}
/**
* @类别 <br>
* @描述
* @see <a href='../../../examples/gallery/editor.html#modelTile'></a>
*/
class PolygonTile extends Item {
protected _scene: any;
private _viewer;
protected _provider: any;
protected _name: any;
protected _tileCacheSize: any;
protected _color: any;
protected _isPick: any;
protected _pickedColor: any;
protected _minLevel: any;
protected _maxLevel: any;
protected _pickInstance: any;
protected _pickTile: any;
protected _pickPrimitive: any;
protected _changed: Cesium.Event;
protected _error: Cesium.Event;
protected _loading: Cesium.Event;
protected _isLoading: boolean;
protected _entityCluster: Cesium.EntityCluster;
protected _entityCollection: Cesium.EntityCollection;
protected _loaded: boolean;
protected _tileReplacementQueue: any;
protected _renderTiles: Cesium.AssociativeArray;
protected _pickEvent: Cesium.Event;
protected _outColor: any;
protected _oldInstance: any;
protected _id: string;
private _isExtruded;
private _extrudedHeight;
/**
*
* @param options
* @returns
* ```
*
* let polygonTileTileOpt = new GV.PolygonTileTileOpt(urlService, layer);
* polygonTileTileOpt.color = '#ffffff';
* let polygonTile = new GV.PolygonTile(polygonTileTileOpt);
* viewer.tileLayer.add(polygonTile);
* ```
*/
constructor(options: PolygonTileOpt, name?: string);
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
*
* @param {GeoCanvas}
*/
initItem(viewer: GeoCanvas): void;
/**
*
*/
destroyItem(): void;
/**
*
* @param {Function} callback
*/
onPick: Function;
/**
*
* @memberof ModelTileDataSource
*/
/**
*
* @memberof ModelTileDataSource
*/
name: any;
/**
*
* @memberof ModelTileDataSource
*/
private readonly clock;
/**
*
* @memberof ModelTileDataSource
*/
private readonly entities;
/**
*
* @memberof ModelTileDataSource
*/
private readonly isLoading;
/**
*
* @memberof ModelTileDataSource
*/
private readonly changedEvent;
/**
*
* @memberof ModelTileDataSource
*/
private readonly pickEvent;
/**
*
* @memberof ModelTileDataSource
*/
private readonly errorEvent;
/**
*
* @memberof ModelTileDataSource
*/
private readonly loadingEvent;
/**
*
* @memberof ModelTileDataSource
*/
/**
*
* @memberof ModelTileDataSource
*/
private show;
/**
*
* @memberof ModelTileDataSource
*/
/**
*
* @memberof ModelTileDataSource
*/
private clustering;
/**
* @private
* @memberof ModelTileDataSource
*/
private findTileFromCache;
/**
* @private
* @memberof ModelTileDataSource
*/
private handleParentAndChildren;
/**
* @private
* @memberof ModelTileDataSource
*/
private createModel;
/**
* @private
* @memberof ModelTileDataSource
*/
private processModel;
/**
* @private
* @memberof ModelTileDataSource
*/
private processFeature;
/**
* @private
* @memberof ModelTileDataSource
*/
private loadModelData;
/**
* @private
* @memberof ModelTileDataSource
*/
private processTile;
/**
* @private Key值
* @memberof ModelTileDataSource
*/
private getRenderTileKeys;
/**
* @private
* @memberof ModelTileDataSource
*/
private update;
/**
* @private
* @memberof ModelTileDataSource
*/
private destroy;
}
/**
*
* icenter配合的特定功能url当前对外呈现的是wmts的方式接入wms等
*/
class PolygonTileOpt {
/**服务地址 */
url: string;
/**图层信息 */
layer: string;
/**面颜色 */
color: string;
/**显示最小层级 (范围:>=0 && <=22*/
minLevel: number;
/**显示最大层级 (范围:>=0 && <=22*/
maxLevel: number;
/**是否选中 */
isPick: boolean;
/**是否拉伸 */
isExtruded: boolean;
/**选中后颜色 */
pickedColor: string;
/**拉伸高度 */
extrudedHeight: number;
constructor(url: string, layer: string, color?: string, minLevel?: number, maxLevel?: number, isPick?: boolean, isExtruded?: boolean, pickedColor?: string, extrudedHeight?: number);
}
class TileLayer extends Layer {
_viewer: Cesium.Viewer;
constructor(viewer: Cesium.Viewer);
/**
*
* @param item
*/
add(item: Item): Item;
/**
*
* @param
*/
remove(value: string | Item): Item;
/**
* json
* @param json
*/
parseJson(json: any): void;
}
class TMSVectorProvider {
protected _url: any;
protected _format: any;
protected _minLevel: any;
protected _maxLevel: any;
protected _tilingScheme: any;
constructor(options: any);
readonly minLevel: any;
readonly maxLevel: any;
requestVectorTile(level: any, x: any, y: any, success: any, failure: any): any;
requestPromise(level: any, x: any, y: any): any;
}
class VectorTile {
private _level;
private _x;
private _y;
private _prepare;
private _visible;
private _removeCount;
private _eligibleForUnloading;
private _replacementPrevious;
private _replacementNext;
private _type;
private _instances;
private _primitive;
private _opt;
onload: Function;
constructor(level: number, x: number, y: number, opt: object);
readonly level: number;
readonly x: number;
readonly y: number;
readonly key: string;
readonly type: string;
primitive: any;
prepare: boolean;
visible: boolean;
removeCount: number;
eligibleForUnloading: boolean;
replacementPrevious: any;
replacementNext: any;
isEqual(level: number, x: number, y: number): boolean;
isKeyEqual(key: string): boolean;
private coordinatesArrayToCartesianArray;
private createLineString;
private createPolygon;
createGeometry(feature: any): void;
createPrimitive(): any;
destroy(): void;
freeResources(): void;
pick(id: any): any;
resetOriginColor(): void;
}
class VectorTileItem extends Item {
protected _viewer: Cesium.Viewer;
protected _id: string;
protected _opt: VectorTileItemOpt;
protected _resource: any;
protected _tags: any;
protected _renderTiles: any;
protected _eventHandler: any;
protected _pickEvent: any;
protected _pickTile: VectorTile;
protected _entityCollection: any;
protected _cluster: any;
protected _changed: any;
protected _primitives: any;
protected _groundPrimitives: any;
constructor(opt: VectorTileItemOpt);
combineQueryParameters(q1: any, q2: any): Object;
resetResource(url: any): void;
/**
*
*/
getType(): string;
/**
* ()
*/
static readonly type: string;
/**
* Gets the collection of {@link Entity} instances.
* @memberof VectorTileDataSource.prototype
* @type {EntityCollection}
*/
readonly entities: any;
/**
* Gets or sets the clustering options for this data source. This object can be shared between multiple data sources.
*
* @memberof VectorTileDataSource.prototype
* @type {EntityCluster}
*/
private clustering;
private readonly changedEvent;
readonly minLevel: number;
readonly maxLevel: number;
/**
* @注意 item的基类方法,
* @描述 add方法添加时被调用
*/
initItem(viewer: Cesium.Viewer): any;
/**
* @注意 item的基类方法,
* @描述 remove方法添加时被调用
*/
destroyItem(): void;
private destroy;
private _control;
/**
*
* GeographicTilingScheme和WebMercatorTilingScheme两种方式
*/
doOriginTiles(): void;
doConvertTiles(): void;
doCreateTiles(): void;
doRequest(tile: any): any;
doAnalysis(tile: any): void;
doCreateGeometry(tile: any): void;
doCreatePrimitive(tile: any): void;
doProcessTiles(): void;
update(time: any): boolean;
/**
*
* @param {Function} callback
*/
onPick: Function;
}
class VectorTileItemOpt {
providerType: string;
url: string;
layer?: string;
tilematrixset?: string;
format?: string;
minLevel?: number;
maxLevel?: number;
tilingScheme?: any;
lineWidth?: number;
lineColor?: string;
fillColor?: string;
pickColor?: string;
constructor(type?: string);
}
class WMTSVectorProvider {
protected _url: any;
protected _layer: any;
protected _format: any;
protected _tilematrixset: any;
protected _style: any;
protected _version: any;
protected _minLevel: any;
protected _maxLevel: any;
constructor(options: any);
readonly minLevel: any;
readonly maxLevel: any;
requestVectorTile(level: any, x: any, y: any, success: any, failure: any): any;
requestPromise(level: any, x: any, y: any): any;
}
/**
* KMLLayer图层
*/
class GeoJsonLayer extends VectorItem {
private _renderObj;
private _vectorLayer;
private _option;
private _type;
constructor(option: GeoJsonLayerOpt);
/**
*
*/
getType(): string;
static readonly type: string;
initItem(geojsonlayer: VectorLayer): void;
destroyItem(): void;
getRenderObject(): Cesium.DataSource;
parseOption(option: any): void;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(option: any): void;
}
class GeoJsonLayerOpt {
/**
* geojson路径
*/
url: string;
stroke: Cesium.Color;
fill: Cesium.Color;
strokeWidth: number;
}
/**
* KMLLayer图层
*/
class KMLLayer extends VectorItem {
private _renderObj;
private _vectorLayer;
private _option;
private _type;
constructor(option: KMLLayerOpt);
/**
*
*/
getType(): string;
static readonly type: string;
initItem(kmllayer: VectorLayer): void;
destroyItem(): void;
getRenderObject(): Cesium.DataSource;
parseOption(option: any): void;
/**
* json数据
* ```
* :
* const obj = item.toJson();
* ```
*/
toJson(): object;
/**
* json对象
*/
parseJson(option: any): void;
}
class KMLLayerOpt {
/**
* kml路径
*/
url: string;
}
class VectorItem extends Item {
constructor();
getRenderObject(): Cesium.DataSource;
}
class VectorLayer extends Layer {
_viewer: Cesium.Viewer;
_renderItemList: any[];
constructor(viewer: Cesium.Viewer);
/**
*
* @param item
*/
add(item: Item): Item;
/**
*
* @param
*/
remove(itemid: string | Item): Item;
/**
* json
* @param json
*/
parseJson(json: any): void;
getItemList(): Item[];
/**
*
*/
getRenderObject(): Cesium.DataSourceCollection;
getRenderItemById(id: string): any;
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 Building参数类</br>
*/
class BuildingOpt {
/**
* URLShapeFile文件格式
*/
url: string;
/**
*
*/
onLoad: Function;
/**
*
*/
onError: Function;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class Building {
/**
* @readonly
*
*/
private readonly buildingOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "Building";
/**
* @readonly
*
*/
readonly url: string;
/**
* @readonly
*
*/
readonly onLoad: string;
/**
* @readonly
*
*/
readonly onError: string;
/**
*
* @param buildingOpt
* ```
*
* let building = new GV.Building({
* url: "./3d/assets/shpdata/building.shp",
* onLoad: () => {
* console.log("建筑物加载完成");
* // 删除建筑物
* // localSceneManager.remove(building);
* },
* onError: () => {
* console.error("建筑物加载失败");
* }
* });
* localSceneManager.add(building);
* ```
*/
constructor(buildingOpt: BuildingOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 FlyLine参数类</br>
*/
class FlyLineOpt {
/**
* URLShapeFile文件格式
*/
url: string;
/**
*
*/
onLoad: Function;
/**
*
*/
onError: Function;
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class FlyLine {
/**
* @readonly
*
*/
private readonly flyLineOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "FlyLine";
/**
* @readonly
*
*/
readonly url: string;
/**
* @readonly
*
*/
readonly onLoad: string;
/**
* @readonly
*
*/
readonly onError: string;
/**
*
* @param flyLineOpt
* ```
*
* let flyLine = new GV.FlyLine({
* url: "./3d/assets/shpdata/road.shp",
* onLoad: () => {
* console.log("交通线加载完成");
* // 删除建筑物
* // localSceneManager.remove(flyLine);
* },
* onError: () => {
* console.error("交通线加载失败");
* }
* });
* localSceneManager.add(flyLine);
* ```
*/
constructor(flyLineOpt: FlyLineOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 Grass参数类</br>
*/
class GrassOpt {
/**
* URL
*/
url: string;
/**
*
*/
path: Array<Number>;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class Grass {
/**
* @readonly
*
*/
private readonly grassOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "Grass";
/**
* @readonly
* URL
*/
readonly url: string;
/**
* @readonly
*
*/
readonly path: Array<Number>;
/**
*
* @param grassOpt
* ```
*
* let grass = new GV.Grass({
* url: '3d/models/grasslight-big.jpg',
* path: [116.511605918892, 39.89511659484216,
* 116.51340673914781, 39.89603267315914,
* 116.513045850042, 39.8928623748469,
* 116.50992528493731, 39.893017145617556,
* 116.50987253858077, 39.896225794700904]
* });
* localSceneManager.add(grass);
* ```
*/
constructor(grassOpt: GrassOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 Lake参数类</br>
*/
class LakeOpt {
/**
*
*/
path: Array<Number>;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class Lake {
/**
* @readonly
*
*/
private readonly lakeOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "Lake";
/**
* @readonly
*
*/
readonly path: Array<Number>;
/**
*
* @param lakeOpt
* ```
*
* let lake = new GV.Lake({
* path: [116.46394483232434, 39.92116198177896,
* 116.47100428927826, 39.920750253307425,
* 116.47100465291112, 39.91530110288575,
* 116.46448546148142, 39.9165185653711]
* });
* localSceneManager.add(lake);
* ```
*/
constructor(lakeOpt: LakeOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 ArcFlyLine参数类</br>
*/
class ArcFlyLineOpt {
/**
* 1
*/
point1: Array<Number>;
/**
* 2
*/
point2: Array<Number>;
/**
*
*/
height?: Number;
}
/**
* @类型 使
* @描述 线
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class ArcFlyLine {
/**
* @readonly
*
*/
readonly arcFlyLineOpt: ArcFlyLineOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "ArcFlyLine";
/**
* @readonly
* 1
*/
readonly point1: Array<Number>;
/**
* @readonly
* 2
*/
readonly point2: Array<Number>;
/**
* @readonly
*
*/
readonly height?: Number;
/**
*
* @param arcFlyLineOpt
* ```
*
* let arcFlyLine = new GV.ArcFlyLine({
* point1: [116.51371956748655, 39.896977168243296],
* point2: [116.51303281179823, 39.8846319497709],
* height: 2000
* });
* localSceneManager.add(arcFlyLine);
* ```
*/
constructor(arcFlyLineOpt: ArcFlyLineOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 Cone参数类</br>
*/
class ConeOpt {
/**
*
*/
position: Array<Number>;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class Cone {
/**
* @readonly
*
*/
readonly coneOpt: ConeOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "Cone";
/**
* @readonly
*
*/
readonly position: Array<Number>;
/**
*
* @param coneOpt
* ```
*
* let coneOpt = new GV.Cone({
* position: [116.51076048913382, 39.90802960257902]
* });
* localSceneManager.add(coneOpt);
* ```
*/
constructor(coneOpt: ConeOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 DiffusionCircle参数类</br>
*/
class DiffusionCircleOpt {
/**
*
*/
position: Array<Number>;
/**
*
*/
radius?: Number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class DiffusionCircle {
/**
* @readonly
*
*/
readonly diffusionCircleOpt: DiffusionCircleOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "DiffusionCircle";
/**
* @readonly
*
*/
readonly position: Array<Number>;
/**
* @readonly
*
*/
readonly radius?: Number;
/**
*
* @param diffusionCircleOpt
* ```
*
* let diffusionCircle = new GV.DiffusionCircle({
* position: [116.50338122228361, 39.90305240890057]
* });
* localSceneManager.add(diffusionCircle);
* ```
*/
constructor(diffusionCircleOpt: DiffusionCircleOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 Instructions参数类</br>
*/
class InstructionsOpt {
/**
*
*/
path: Array<Number>;
/**
*
*/
height?: Number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class Instructions {
/**
* @readonly
*
*/
readonly instructionsOpt: InstructionsOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "Instructions";
/**
* @readonly
*
*/
readonly path: Array<Number>;
/**
* @readonly
*
*/
readonly height?: Number;
/**
*
* @param instructionsOpt
* ```
*
* let instructions = new GV.Instructions({
* path: [116.48383039748049, 39.89778212327162,
* 116.48387968022607, 39.90346024265005,
* 116.48425004693271, 39.90496962851058,
* 116.48541803370951, 39.905568214747916,
* 116.48736908028644, 39.90625677748452,
* 116.4901205676712, 39.906519972554705,
* 116.49207414308337, 39.90645163809704,
* 116.4953625014651, 39.90645165387379],
* height: 300
* });
* localSceneManager.add(instructions);
* ```
*/
constructor(instructionsOpt: InstructionsOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 Panel参数类</br>
*/
class PanelOpt {
/**
* 'sprite' 'object'
*/
panelType?: String;
/**
* div对象
*/
divElement: Element;
/**
*
*/
position: Array<Number>;
/**
* 线
*/
height?: Number;
/**
*
*/
anchor?: Array<Number>;
}
/**
* @类型 使
* @描述 3D面板
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class Panel {
/**
* @readonly
* 'sprite' 'object'
*/
readonly panelType?: String;
/**
* @readonly
*
*/
readonly panelOpt: PanelOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "Panel";
/**
* @readonly
* div对象
*/
readonly divElement: Element;
/**
* @readonly
*
*/
readonly position: Array<Number>;
/**
* @readonly
* 线
*/
readonly height?: Number;
/**
* @readonly
*
*/
readonly anchor?: Array<Number>;
/**
*
* @param panelOpt
* ```
*
* var element = document.createElement('div');
* element.className = 'element';
* element.style.backgroundColor = 'rgba(0,127,127,' + (Math.random() * 0.5 + 0.25) + ')';
* var number = document.createElement('div');
* number.className = 'number';
* number.textContent = 'geovis';
* element.appendChild(number);
* var symbol = document.createElement('div');
* symbol.className = 'symbol';
* symbol.textContent = '中科星图';
* element.appendChild(symbol);
* var logo = document.createElement('div');
* logo.className = 'logo';
* logo.textContent = '该公司属于软件行业和地理信息产业,为国家重点支持和鼓励发展的行业,是新一代信息技术重要方向.';
* element.appendChild(logo);
* var details = document.createElement('div');
* details.className = 'details';
* details.innerHTML = '北京.顺义';
* element.appendChild(details);
* let panel = new GV.Panel({
* position: [116.509553191, 39.903305825500055],
* height: 300,
* divElement: element
* });
* localSceneManager.add(panel);
* ```
*/
constructor(panelOpt: PanelOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 Particles参数类</br>
*/
class ParticlesOpt {
/**
* fire rain snow
*/
name: String;
/**
*
*/
positions: Array<Number>;
/**
*
*/
height?: Number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class Particles {
/**
* @readonly
*
*/
readonly particlesOpt: ParticlesOpt;
/**
* @readonly
* fire rain snow
*/
readonly name: String;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "Particles";
/**
* @readonly
*
*/
readonly positions: Array<Number>;
/**
* @readonly
*
*/
readonly height?: Number;
/**
*
* @param particlesOpt
* ```
*
* let fire = new GV.Particles(
* {
* name: "fire",
* position: [116.48994770868715, 39.90351968042573],
* height: 500,
* }
* );
* localSceneManager.add(fire);
* ```
*/
constructor(particlesOpt: ParticlesOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 POI参数类</br>
*/
class POIOpt {
/**
* URL
*/
url: string;
/**
*
*/
positions: Array<Number>;
/**
*
*/
size?: Array<Number>;
/**
*
*/
anchor?: Array<Number>;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class POI {
/**
* @readonly
*
*/
readonly spriteOpt: POIOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "POI";
/**
* @readonly
* URL
*/
readonly url: string;
/**
* @readonly
*
*/
readonly positions: Array<Number>;
/**
* @readonly
*
*/
readonly size?: Array<Number>;
/**
* @readonly
*
*/
readonly anchor?: Array<Number>;
/**
*
* @param spriteOpt
* ```
*
* let pos = [];
* for (let i = 0; i < 30; i++) {
* pos.push(116.509553191 - Math.random() / 40, 39.903305825500055 - Math.random() / 40);
* }
* let sprite = new GV.Sprite({
* positions: pos,
* url: "./3d/models/icon.png"
* });
* localSceneManager.add(sprite);
* ```
*/
constructor(spriteOpt: POIOpt);
}
/**
* @类别 ThreeJS扩展类</br>
* @描述 Sprite参数类</br>
*/
class SpriteOpt {
/**
* URL
*/
url: string;
/**
*
*/
positions: Array<Number>;
/**
*
*/
size?: Number;
}
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class Sprite {
/**
* @readonly
*
*/
readonly spriteOpt: SpriteOpt;
/**
* @readonly
* id属性为只读
*/
readonly id: any;
/**
* @readonly
*
*/
readonly type = "Sprite";
/**
* @readonly
* URL
*/
readonly url: string;
/**
* @readonly
*
*/
readonly positions: Array<Number>;
/**
* @readonly
*
*/
readonly size?: Number;
/**
*
* @param spriteOpt
* ```
*
* let pos = [];
* for (let i = 0; i < 30; i++) {
* pos.push(116.509553191 - Math.random() / 40, 39.903305825500055 - Math.random() / 40);
* }
* let sprite = new GV.Sprite({
* positions: pos,
* url: "./3d/models/icon.png"
* });
* localSceneManager.add(sprite);
* ```
*/
constructor(spriteOpt: SpriteOpt);
}
var THREE: any;
/**
* @类型 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#cityNew'></a>
*/
class LocalSceneManager extends THREE.EventDispatcher {
/**
* GeoCanvas
*/
private viewer;
/**
* Three管理器
*/
private threeManager;
/**
*
* @param viewer GeoCanvas
* @param bloomDebug Bloom调试面板
* @param stats
* @param bloomParams Bloom参数 exposure 1.7 bloomStrength 1.2 bloomThreshold 0 bloomRadius 1.0
* ```
*
* let localSceneManager = new GV.LocalSceneManager(this.viewer);
* ```
*/
constructor(viewer: any, bloomDebug?: Boolean, stats?: Boolean, bloomParams?: any);
/**
*
* @param param
* ```
*
* let localSceneManager = new GV.LocalSceneManager(this.viewer);
* localSceneManager.add(object);
* object可以是Building/FlyLine/Grass/Lake/ArcFlyLine/DiffusionCircle/Instructions/Panel/Sprite实例
* ```
*/
add(param: any): void;
/**
*
* @param param
* ```
*
* let localSceneManager = new GV.LocalSceneManager(this.viewer);
* localSceneManager.remove(object)
* object可以是Building/FlyLine/Grass/Lake/ArcFlyLine/DiffusionCircle/Instructions/Panel/Sprite实例
* ```
*/
remove(param: any): void;
/**
*
*/
private animate;
/**
*
*/
private render;
}
/**
* Cesium适配器
*/
class CesiumThreeUtil {
/**
* ThreeJS画布div
*/
static createThreeDiv(viewer: any): Element;
/**
*
*/
static convertCoordinateSystem(): void;
}
/**
*
* @param params
*/
function Property(target: any, propertyKey: string): void;
/**
*
*
* dongb@geovis.com
* 2019-3-18
*/
/**
* {@link Tool} {@link Widget}
*/
class PluginBase {
_active: boolean;
_type: any;
_name: any;
_path: any;
/**
* @param {Object} optins
* @param {PluginManager} pluginManager
*/
constructor(optins: any, pluginManager: any);
/**
*
* @type {boolean}
* @readonly
*/
readonly active: boolean;
/**
*
* @type {stirng}
* @readonly
*/
readonly type: any;
/**
* ()
* @type {string}
* @readonly
*/
readonly name: any;
/**
*
*/
readonly path: any;
/**
*
*/
init(): void;
/**
*
*/
close(): void;
/**
*
*/
getPluginData(): void;
/**
*
*/
setPluginData(data: any): void;
/**
*
* @param {string} file
*/
formatURL(file: any): any;
_init(): void;
_close(): void;
}
/**
*
*
* dongb@geovis.com
* 2019-3-18
*/
/**
*
* {@link Tool} {@link Widget}
*/
class PluginManager extends Event {
_plugins: Map<any, any>;
_currentTool: any;
_pluginInitOptins: any;
constructor(pluginInitOptins: any);
/**
*
* @param {string} name
* @return {plugin}
*/
addPlugin(name: any): any;
/**
*
* @param {string | Plugin} plugin
*/
removePlugin(plugin: any): void;
/**
*
* @param {string | Tool} tool
*/
setCurrentTool(tool: any): void;
/**
*
*/
closeTool(tool: any): void;
/**
*
*/
closeAllTool(): void;
/**
*
* @param {widget | string}
*/
usingWidget(widget: any): any;
/**
*
* @param {widget | string}
*/
unusingWidget(widget: any): any;
/**
*
* @return {[Plugin]}
*/
getAllPlugin(): any[];
/**
*
* @return {[Tool]}
*/
getAllTools(): any[];
/**
*
* @return {[Tool]}
*/
getAllWidgets(): any[];
/**
*
* @return {[Tool]}
*/
getAllUsingWidgets(): any[];
/**
*
* @return {[Tool]}
*/
getCurrentTool(): any;
}
/**
*
*/
class PluginsFactory {
_pluginMap: Map<any, any>;
constructor();
/**
*
* @param {options|string} pluginOptions
* @param {string} pluginOptions.name
* @param {string} pluginOptions.path
* @param {string} pluginOptions.js
*/
registerPlugin(pluginOptions: any): any;
/**
*
*/
_registerPlugin(options: any): any;
/**
* script
* @param {String} path
*/
_appendScript(path: any): boolean;
/**
*
* @param {string|object} pluginOptions
*/
_getPluginPath(pluginOptions: any): any;
/**
*
* @param {String} name
*/
destroyPlugin(name: any): void;
/**
* 使
* @param {String} name
* @param {Object} options
* @param {pluginManager} PluginManager
* @return {PluginBase}
*/
createPlugin(name: any, options: any, pluginManager: any): any;
}
let pluginsFactory: PluginsFactory;
/**
*
* 2019-04-09
*/
/**
*
*/
class PluginThemeManager {
_themeStyle: {};
constructor();
/**
*
*/
themeStyle: any;
createStyle(styleParam: any, doc: any): void;
createAllStyle(styleParam: any): void;
/**
*
* @param {document} doc
* @param {object} styleParam
*/
generateDocStyle(doc: any): void;
_generateDocStyle(doc: any, styleParam: any): void;
_getThemeStyle(styleParam: any): {};
_getStyleCss(tempStyle: any): string;
toCssStyle(str: any): any;
colorRgb(col: any): string;
}
let pluginThemeManager: PluginThemeManager;
/**
*
*
* dongb@geovis.com
* 2019-3-18
*/
/**
*
*/
class PluginView {
_container: any;
_url: any;
_viewStyle: any;
state: string;
_instance: HTMLIFrameElement;
containerDiv: HTMLDivElement;
/**
* iframe插件视图
* @param {object} options
* @param {Element} options.container
* @param {String} options.url html路径
* @param {object} [options.viewStyle=undefined] 使
* @param {options} [options.viewStyle.width]
* @param {options} [options.viewStyle.height]
* @param {options} [options.viewStyle.left]
* @param {options} [options.viewStyle.top]
* @param {options} [options.viewStyle.right]
* @param {options} [options.viewStyle.bottom]
* @return {PluginView}
*/
constructor(options: any);
/**
*
* @return {element}
*/
readonly instance: HTMLIFrameElement;
/**
*
*/
show(): void;
/**
*
*/
hide(): void;
/**
*
*/
close(): void;
/**
* div
* @param {viewer} viewer
* @param {element} div
*/
setMouseBaseElement(viewer: any, div: any): void;
/**
* div
* @param {Viewer} viewer
*/
resetMouseBaseElement(viewer: any): void;
_createIframe(url: any): HTMLIFrameElement;
_createDiv(options: any): HTMLDivElement;
_setStylePro(element: any, options: any): void;
}
/**
*
*
* dongb@geovis.com
* 2019-3-18
*/
/**
* ()
* {@link PluginManager}.
*
* @augments PluginBase
*/
class Tool extends PluginBase {
_isHide: boolean;
/**
* @param {PluginManager} prents
* @param {Object} optins
*/
constructor(prents: any, optins: any);
/**
* true
* @type {boolean}
* @readonly
*/
readonly isHide: boolean;
/**
*
*/
_init(): void;
/**
*
*/
_hide(): void;
hide(): any;
/**
*
*/
_close(): void;
}
/**
*
*
* dongb@geovis.com
* 2019-3-18
*/
/**
* ()
* {@link PluginManager}.
*
* @augments PluginBase
*/
class Widget extends PluginBase {
/**
* @param {PluginManager} prents
* @param {Object} optins
*/
constructor(prents: any, optins: any);
}
/**
* 耀
* 2020-08-05
*/
/**
* DQG网格计算行内网格经差
* @param n
*/
function log2_d(n: number): number;
/**
*
* @param camera
* @returns {number}
*/
function computeRadius(camera: any): number;
/**
*
* @param zeroTile
* @param cameraInfo
*/
function zeroTileVisible(zeroTile: TriangleTile | QuadTile, cameraInfo: any): boolean;
/**
*
* @param {QuadTile} quadTile
* @param {any} cameraInfo
*/
function isQuadTileVisible(quadTile: QuadTile, cameraInfo: any): boolean;
/**
*
* @param tile
* @param rect
*/
function isRectContainTile(tile: TriangleTile | QuadTile, rect: any): boolean;
/**
* DQG编码的行列号
* @param lon
* @param lat
* @param level
* @return obj
*/
function lonLatToRowCol(lon: number, lat: number, level: number): any;
/**
* DQG编码的行列高
* @param lon
* @param lat
* @param alt
* @param level
* @param relativeHeight 10019000 >> level
* @param height 0.1
* @return obj
*/
function lonLatAltToRowColHei(lon: number, lat: number, alt: number, level: number, relativeHeight?: number, height?: number): any;
/**
*
* @param row
* @param col
* @param level
*/
function rowColToLonLat(row: number, col: number, level: number): any;
/**
* 线
* @param {*} cameraInfo
* @param {*} tileList
* @param {*} outlineInstances
*/
function outlineInstance(cameraInfo: any, tileList: any, outlineInstances: any): Cesium.Primitive;
/**
*
* @param {*} cameraInfo
* @param {*} tileList
* @param {*} surfaceInstances
*/
function surfaceInstance(cameraInfo: any, tileList: any, surfaceInstances: any): Cesium.Primitive;
/**
*
* @param {*} cameraInfo
* @param {*} tileList
* @param {*} outlineInstances
*/
function labelInstance(tileList: any, labelInstances: any): void;
/**
*
*/
class QuadTile {
private _code;
private _preCode;
private _level;
private _west;
private _south;
private _east;
private _north;
private _bHeight;
private _tHeight;
private _cenLon;
private _cenLat;
private _center;
private _LTChild;
private _RTChild;
private _LBChild;
private _RBChild;
private _LMChild;
private _BMChild;
private _RMChild;
private _TMChild;
private _MMChild;
private _row;
private _col;
boundingBox: any;
intersection: any;
changeColor: boolean;
constructor(options: any);
code: any;
level: any;
west: any;
south: any;
east: any;
north: any;
bHeight: any;
tHeight: any;
cenLon: any;
cenLat: any;
readonly center: any;
LTChild: any;
RTChild: any;
LBChild: any;
RBChild: any;
readonly row: number;
readonly col: number;
a: number;
/**
* (DQG网格)
* @param {*} tileList
* @param {*} cameraInfo
*/
update(tileList: any[], cameraInfo: any): void;
initUpdate(tileList: Array<QuadTile>, level: number, scale: number, cameraInfo: any, condition: number): void;
/**
* (DQG网格)
* @param {*} tileList
* @param {*} cameraInfo
*/
DQGUpdate(tileList: Array<QuadTile>, cameraInfo: any): void;
/**
* (DQG网格)
* @param {*} tileList
* @param {*} cameraInfo
*/
staticUpdate(tileList: Array<QuadTile>, cameraInfo: any, rect: any): void;
/**
*
*/
computeChildren(): void;
/**
*
*/
computeNineChildren(): void;
/**
*
*/
computeDQGChildren(): void;
/**
*
*/
computeCustomChildren(code: string, level: number, west: number, south: number, east: number, north: number, cenLon: number, cenLat: number): void;
/**
*
*/
destory(): void;
}
/**
* DQG网格时才会用到
*/
class TriangleTile {
private _code;
private _oct;
private _level;
private _west;
private _south;
private _east;
private _north;
private _bHeight;
private _tHeight;
private _cenLon;
private _cenLat;
private _center;
private _LTChild;
private _RTChild;
private _LBChild;
private _RBChild;
private _row;
private _col;
boundingBox: any;
intersection: any;
changeColor: boolean;
constructor(options: any);
code: any;
level: any;
west: any;
south: any;
east: any;
north: any;
bHeight: any;
tHeight: any;
cenLon: any;
cenLat: any;
readonly center: any;
LTChild: any;
RTChild: any;
LBChild: any;
RBChild: any;
readonly row: number;
readonly col: number;
/**
* (DQG网格)
* @param {*} tileList
* @param {*} cameraInfo
*/
update(tileList: Array<TriangleTile | QuadTile>, cameraInfo: any): void;
/**
*
* @param {*} tileList
* @param {*} cameraInfo
*/
staticUpdate(tileList: Array<TriangleTile | QuadTile>, cameraInfo: any, rect: any): void;
/**
*
*/
computeChildren(): void;
/**
* DQG子格网
*/
computeDQGChildren(): void;
/**
*
*/
destory(): void;
}
class Fog {
near: any;
far: any;
nearFog: any;
farFog: any;
viewer: Cesium.Viewer;
private value;
color: any;
constructor(viewer: Cesium.Viewer, options?: Object);
remove(): void;
enabled: Boolean;
static fragmentShader: String;
}
/**
*
* GeoCanvas时自动在SceneOptions类进行实例化
* 使SceneOptions类说明
*/
class GlobalWater {
private viewer;
private worldRectangle;
constructor(viewer: Cesium.Viewer);
/**
*
*/
showGlobalWater(): void;
/**
*
*/
closeGlobalWater(): void;
/**
* value>0 10000
*/
frequency: Number;
/**
* value>0 0.01
*/
animationSpeed: Number;
/**
* value>0 1.0
*/
amplitude: Number;
}
/**
*
*/
class Graticule {
private layer;
private viewer;
constructor(viewer: Cesium.Viewer);
/**
*
*/
show(): void;
/**
*
*/
remove(): void;
/**
* 线css
*/
color: string;
/**
* 线
*/
width: number;
/**
*
*/
textFont: string;
/**
* css
*/
textColor: string;
/**
* css
*/
textOutlineColor: string;
}
class GraticuleLayer {
private _visible;
private _opt;
private _scene;
private _ellipsoid;
private _polylines;
private _groundPrimitive;
private _labels;
private _extent;
private _levels;
private _sexagesimal;
constructor(opt: GraticuleLayerOpt, viewer: Cesium.Viewer);
listenerFun: () => void;
private decToSex;
private gridPrecision;
/**将经度值限制到-PI到PI之间 */
private normalize;
private getNearestLongitude;
private getNearestLatitude;
/**获取相机视角范围 */
private getExtent;
private makeLabel;
/**绘制网格和文字 */
private drawGrid;
private getMS;
/**获取线颜色 */
/**设置线颜色 */
color: Cesium.Color;
/**获取线宽 */
/**设置线宽 */
width: number;
/**获取文字字体样式 */
/**设置文字字体样式 */
textFont: string;
/**获取文字颜色 */
/**设置文字颜色 */
textColor: Cesium.Color;
/**获取文字轮廓颜色 */
/**设置文字轮廓颜色 */
textOutlineColor: Cesium.Color;
/**获取经纬网是否显示状态 */
isVisible(): Boolean;
/**设置经纬网显示/隐藏 */
setVisible(show: Boolean): void;
}
class GraticuleLayerOpt {
color: Cesium.Color;
width: number;
textFont: string;
textColor: Cesium.Color;
textOutlineColor: Cesium.Color;
constructor(color?: string, w?: number, textFont?: string, textColor?: string);
}
/**
* 耀
* 2020-08-05
*/
/**
* @类型
* @描述 DQG网格
* @see <a href='../../../examples/gallery/editor.html#mapBox'></a>
*/
class MapBox {
private viewer;
private timeID;
private destroyFlag;
private _visible;
private outlinePrimitive;
private surfacePrimitive;
private _outlineColor;
private _height;
private _extrudedHeight;
private _relativeHeight;
private _subdivFactor;
private _name;
private _changed;
private _error;
private _entityCollection;
private _entityCluster;
private _isLoading;
private _loading;
/**
*
* @param viewer GeoCanvas
* @param options
* ```
*
* let viewer = new GV.GeoCanvas('GEOVISContainer');
* // 创建静态网格
* let mapBox = new GV.MapBox({ subdivFactor: 3, outlineColor: 'rgb(100, 100, 100)', relativeHeight: 20000000, height: 1000000 });
* ```
*/
constructor(viewer: GeoCanvas, options?: MapBoxOpt);
/**
*
*/
readonly outlineColor: string;
/**
*
*/
readonly height: number;
/**
*
*/
readonly relativeHeight: number;
/**
*
*/
readonly extrudedHeight: number;
/**
*
*/
readonly subdivFactor: number;
/**继承DataSource属性begin */
private name;
private readonly clock;
private readonly entities;
private readonly isLoading;
private readonly changedEvent;
private readonly errorEvent;
private readonly loadingEvent;
private show;
private clustering;
/**继承DataSource属性end */
/**
*
* @memberof MapSheet
*/
visible: boolean;
/**
*
*/
private remove;
/**
*
* @param options
*/
reSet(options: MapBoxOpt): void;
/**
*
* @param outlineColor
*/
setOutlineColor(outlineColor?: string): void;
/**
*
* @param height
* @param relativeHeight
*/
setHeight(height: number): void;
/**
*
* @param height
* @param relativeHeight
*/
setRelativeHeight(relativeHeight: number): void;
/**
*
* @param height
* @param relativeHeight
*/
setExtrudedHeight(extrudedHeight: number): void;
/**
*
* @param subdivFactor
*/
setSubdivFactor(subdivFactor: number): void;
/**
*
*/
backToDefault(): void;
/**
* DQG网格运行入口
* @param tileList
* @param cameraInfo
*/
private initialDQGUpdate;
/**
*
* @param time
*/
private DQGUpdate;
/**
*
* @param time
*/
private update;
private destroy;
}
class MapBoxOpt {
/** 网格线框颜色 */
outlineColor: string;
/** 网格单元体自身的高度等于extrudedHeight - height */
relativeHeight?: number;
/** 网格单元底面距椭球面高度 */
height?: number;
/** 网格单元挤压面距离椭球面的高度 */
extrudedHeight?: number;
/** 细分阈值 */
subdivFactor: number;
}
/**
* @类型
* @描述 1991GB/T 13989-92
* @see <a href='../../../examples/gallery/editor.html#mapSheet'></a>
*/
class MapSheet {
private gridPrimitive;
private gridScale;
private scale;
private viewer;
private labels;
private labelInfo;
private colseRangeLabels;
private _visible;
private LatCharArray;
private latDArray;
private lonDArray;
private primitive;
private closeRangePrimitive;
private range;
private tileKeys;
private timeID;
private destroyFlag;
private _gridVisable;
private _mapSheetVisable;
private _name;
private _changed;
private _error;
private _entityCollection;
private _entityCluster;
private _isLoading;
private _loading;
constructor(viewer: Cesium.Viewer);
/**继承DataSource属性begin */
private name;
private readonly clock;
private readonly entities;
private readonly isLoading;
private readonly changedEvent;
private readonly errorEvent;
private readonly loadingEvent;
private show;
private clustering;
/**继承DataSource属性end */
/**
*
* @memberof MapSheet
*/
visible: boolean;
gridVisible: boolean;
mapSheetVisible: boolean;
/**
*
*/
private remove;
/**
*
* @param lat
* @param lon
* @param scaleID
* scaleID时
*/
getSheetNumber(lon: number, lat: number, scaleID: LevelCodeEnum): string;
/**
*
* @param sheetNumber
* @param scaleID
* scaleID时
*/
getSheetRange(sheetNumber: string, scaleID: LevelCodeEnum): {
south: any;
east: number;
north: any;
west: number;
};
/**
*
* @param sheetNumber
* @param scaleID
*/
private checkSheetToScale;
/**
*
*/
private splitMap;
/**
* 线label进入场景
* @param data
*/
private createPrimitive;
/**
* label进入场景
* @param data
*/
private createLabel;
/**
*
*/
private getRectangle;
/**
*
* @param tileList
* @param level
* @param scale 1100
* @param cameraInfo
*/
private initialCloseRangeUpdate;
/**
*
*/
private closeRangeUpdate;
/**
*
* @param westGrid
* @param northGrid
* @param eastGrid
* @param southGrid
*/
private addGridPrimitive;
/**
*
* @param time
*/
private update;
destroy(): void;
}
/**
* 耀
* 2020-08-21
*/
/**
* @类型
* @描述 StaticMapBox生成
* PathPlanningOpt中的属性比如网格底面高度heightrelativeHeight
* this.staticMapBox()pathPlanning的初始化
* @see <a href='../../../examples/gallery/editor.html#pathPlanning'></a>
*/
class PathPlanning {
private viewer;
/** 表示不可达地区的网格 */
private inaccesPrimitive;
/** 表示后来自己添加的不可达地区网格 */
private additionInaccesPrimitive;
/** 表示轨迹的网格 */
private gridPathPrimitive;
/** 表示起始位置的网格 */
private startPosPrimitive;
/** 表示终止位置的网格 */
private endPosPrimitive;
private minLon;
private minLat;
private maxLon;
private maxLat;
private minAlt;
private maxAlt;
private startRow;
private startCol;
private endRow;
private endCol;
private startHei;
private endHei;
private inaccesGridArray;
/** 背景网格,轨迹网格的一切均发生在背景网格之内 */
private staticMapBox;
private additionalInaccess;
private level;
private _height;
private _relativeHeight;
/** 轨迹颜色 */
private _pathArrColor;
/** 不可达区域颜色 */
private _inaccesColor;
/** 起点颜色 */
private _strPosColor;
/** 终点颜色 */
private _endPosColor;
/** 是否是三维路径规划(默认值为false) */
private _is3DPathPlanning;
/** 背景网格选项为整个场景提供网格背景和网格环境应跟在pathPlanning之后初始化 */
private backgroundGridsOpt;
/** 不可达区域 */
inaccesRegions: Array<any>;
/** 经纬度转网格行列号 */
lonLatToRowCol: any;
/** 经纬度和高程转为行列高 */
lonLatAltToRowColHei: any;
/** 行列号转经纬度 */
rowColToLonLat: any;
/** 每个不可达区域数组对应的底面高度(minALt)和顶部高度(maxAlt),是个二维数组 */
inaccesRegionsAltArray: Array<any>;
/**
*
* @param viewer GeoCanvas
* @param options
* ```
*
* let viewer = new GV.GeoCanvas('GEOVISContainer');
* // 添加GeoPoint点围成的不可达区域(第一层不可达区域)
* let inaccesRegion1 = [
* new GV.GeoPoint(111.44, 17.28),
* new GV.GeoPoint(113.0, 18.03),
* new GV.GeoPoint(113.8, 16.97),
* new GV.GeoPoint(113.75, 16.48)
* ]
* // 第二层不可达区域(叠在第一层上面,范围比第一层小)
* let inaccesRegion2 = [
* new GV.GeoPoint(111.94, 17.0),
* new GV.GeoPoint(112.5, 17.53),
* new GV.GeoPoint(113.3, 16.47),
* new GV.GeoPoint(113.25, 16.08)
* ]
* // 初始化路径规划场景
* let pathPlanning = new GV.PathPlanning(viewer, { inaccesRegions: [inaccesRegion1, inaccesRegion2], inaccesRegionsAltArray: [[500, 7500], [7500, 14500]], level: 10, height: 400, relativeHeight: 7000 });
* // 创建底图网格
* pathPlanning.setBackgroundGrids({ west: 108.5, south: 14.5, east: 116.5, north: 18.7, level: 10, heightLevel: 2, height: 400, relativeHeight: 7000, outlineColor: 'rgb(150, 150, 150)', color: 'rgba(100, 100, 100, 0.1)', isDrawEachGrid: false });
* ```
*/
constructor(viewer: GeoCanvas, options: PathPlanningOpt);
/** 设置路径网格颜色 */
/** 获取路径网格颜色 */
pathArrColor: string;
/** 设置不可达区域网格颜色 */
/** 获取不可达区域网格颜色 */
inaccesColor: string;
/** 设置起点网格颜色 */
/** 获取起点网格颜色 */
strPosColor: string;
/** 设置终点网格颜色 */
/** 获取终点网格颜色 */
endPosColor: string;
/** 设置网格单元高度 */
/** 获取网格单元高度 */
relativeHeight: number;
/** 设置是否是三维路径规划 */
/** 获取是否是三维路径规划 */
is3DPathPlanning: boolean;
/**
*
* @param startPosX
* @param startPosY
* @param startPosZ
* @param endPosX
* @param endPosY
* @param endPosZ
* @param inaccesGridArray
*/
private dynamicPlanning;
/**
*
* @param lon
* @param lat
* @param alt ()
*/
selectStartGrid(lon: number, lat: number, alt?: number): void;
/**
*
* @param row
* @param col
* @param hei 00
*/
setStartGrid(row: number, col: number, hei?: number): void;
/**
*
* @param lon
* @param lat
* @param alt ()
*/
selectEndGrid(lon: number, lat: number, alt?: number): void;
/**
*
* @param row
* @param col
* @param hei 00
*/
setEndGrid(row: number, col: number, hei?: number): void;
/**
*
* @param lon
* @param lat
* @param alt ()
*/
addInaccesGrid(lon: number, lat: number, alt?: number): void;
/** 绘制路径 */
drawPath(): void;
/**
*
*
*/
drawInaccesGrid(): void;
/**
*
* pathPlanning创建后调用使
*/
setBackgroundGrids(options: StaticMapBoxOpt): void;
/**
*
*/
update(): void;
/**
*
* @param inaccesRegion GeoPoint点围成的不可达区域
*
*/
createInaccesRegion(inaccesRegion: Array<GeoPoint>): any;
/**
*
*/
clearPath(): void;
/**
*
*/
clearInaccesGrid(): void;
/**
* destroy函数
*/
clearAll(): void;
/** 清空 */
destory(): void;
}
/** 路径规划选项 */
class PathPlanningOpt {
/** 不可达区域 */
inaccesRegions: Array<any>;
/** 层级 */
level?: number;
/** 底面相对于椭球面高度 */
height?: number;
/** 单个网格的相对高度 */
relativeHeight?: number;
/** 是否是3维路径规划 */
is3DPathPlanning?: boolean;
/** 路径颜色 */
pathArrColor?: string;
/** 不可达区域颜色 */
inaccesColor?: string;
/** 起点位置颜色 */
strPosColor?: string;
/** 终点位置颜色 */
endPosColor?: string;
/**
* ,
* [[1minAlt, maxAlt], [2minAlt, maxAlt],...]
*/
inaccesRegionsAltArray?: Array<any>;
}
class Rain {
angle: any;
speed: any;
private viewer;
private value;
/**
*
* @param viewer
* @param options
* @param {Number} [options.angle=-15] 线
* @param {Number} [options.speed=240]
*/
constructor(viewer: Cesium.Viewer, options?: any);
remove(): void;
enabled: Boolean;
static fragmentShader: String;
}
/**
*
*/
enum WeatherEnmu {
/**
*
*/
None = 0,
/**
*
*/
Rain = 1,
/**
*
*/
Snow = 2,
/**
*
*/
Fog = 3
}
/**
*
*/
enum LevelCodeEnum {
/**
* 1:100万比例尺
*/
LevelCodeZero = 0,
/**
* 1:50万比例尺
*/
LevelCodeOne = 1,
/**
* 1:25万比例尺
*/
LevelCodeTwo = 2,
/**
* 1:10万比例尺
*/
LevelCodeThree = 3,
/**
* 1:5万比例尺
*/
LevelCodeFour = 4,
/**
* 1:2.5万比例尺
*/
LevelCodeFive = 5,
/**
* 1:1万比例尺
*/
LevelCodeSix = 6
}
/**
* @类别 <br>
* @描述 <br>
* @see <a href='../../../examples/gallery/editor.html#jingWeiWang'></a>
* @see <a href='../../../examples/gallery/editor.html#weather_snow_rain'></a>
* ```
*
* var viewer = new GV.GeoCanvas('GEOVISContainer', {
* sceneOptions:{
* graticule:true,
* weather:GV.WeatherEnmu.Rain
* }
* });
* ```
*/
class SceneOptions {
/**
*
*/
private viewer;
/**
*
*/
private sky;
/**
*
*/
private jingwei;
private _graticule;
/**
*
*/
private _shadowFlag;
/**
*
*/
private _mapSheet;
private _tufu;
/**
*
*/
private _mapBox;
/**
*
*/
private _staticMapBox;
/**
*
*/
private _globalWater;
private _globalWaterVisible;
/**
*
* ```
*
* viewer.sceneOptions.graticule = true
* ```
*/
graticule: Boolean;
private _weather;
shadowFlag: boolean;
/**
*
* ```
*
* viewer.sceneOptions.weather = WeatherEnmu.Rain
* ```
*/
weather: WeatherEnmu;
/**
*
*/
readonly mapSheet: MapSheet;
/**
*
*/
readonly mapBox: MapBox;
/**
*
*/
readonly staticMapBox: StaticMapBox;
/**
*
*/
globalWater: boolean;
readonly globalWaterObj: GlobalWater;
/**
*
* ```
*
* let projection = viewer.sceneOptions.mapProjection;
* ```
*/
readonly mapProjection: string;
/**
*
* @param viewer
* @param options
*/
constructor(viewer: GeoCanvas, options: Object);
}
class Snow {
alpha: any;
speed: any;
private viewer;
private value;
/**
*
* @param viewer
* @param options
* @param {Number} [options.alpha=0.6] 01
* @param {Number} [options.speed=240]
*/
constructor(viewer: Cesium.Viewer, options?: any);
remove(): void;
enabled: Boolean;
static fragmentShader: String;
}
/**
* 耀
* 2020-08-05
*/
/**
* @类型
* @描述 DQG网格
* @see <a href='../../../examples/gallery/editor.html#staticMapBox'></a>
*/
class StaticMapBox {
private viewer;
private _visible;
private outlinePrimitive;
private surfacePrimitive;
private timeID;
private destroyFlag;
private isDraw;
/** 实体西边框经度 */
private _west;
/** 实体南边框纬度 */
private _south;
/** 实体东边框经度 */
private _east;
/** 实体北边框纬度 */
private _north;
/** 实体网格剖分层级,相当于细分阈值 */
private _level;
/** 实体网格相对椭球面的高度 */
private _height;
/** 实体网格挤压面相对于椭球面的高度 */
private _extrudedHeight;
/** 实体网格单元自身的高度 */
private _relativeHeight;
/** 实体网格径向(高度维)上网格层级或数量 */
private _heightLevel;
/** 实体网格外边框颜色 */
private _outlineColor;
/** 实体网格体颜色 */
private _color;
/** 实体网格是否单独绘制每个网格体默认false 若为true可能会影响绘制效率 */
private _isDrawEachGrid;
/** 所有要展现出来的网格 */
resultTileList: Array<TriangleTile | QuadTile>;
private _name;
private _changed;
private _error;
private _entityCollection;
private _entityCluster;
private _isLoading;
private _loading;
/**
*
* @param viewer GeoCanvas
* @param options
* ```
*
* let viewer = new GV.GeoCanvas('GEOVISContainer');
* // 创建静态网格
* let staticMapBox = new GV.StaticMapBox({ west: 108.5, south: 14.5, east: 116.5, north: 18.7, level: 10, heightLevel: 2, height: 400, relativeHeight: 7000, outlineColor: 'rgb(150, 150, 150)', color: 'rgba(100, 100, 100, 0.1)', isDrawEachGrid: false });
* ```
*/
constructor(viewer: GeoCanvas, options?: StaticMapBoxOpt);
/**
* 西
*/
readonly west: number;
/**
*
*/
readonly south: number;
/**
*
*/
readonly east: number;
/**
*
*/
readonly north: number;
/**
*
*/
readonly level: number;
/**
*
*/
readonly height: number;
/**
*
*/
readonly relativeHeight: number;
/**
*
*/
readonly extrudedHeight: number;
/**
*
*/
readonly heightLevel: number;
/**
*
*/
readonly color: string;
/**
*
*/
readonly outlineColor: string;
isDrawEachGrid: any;
/**继承DataSource属性begin */
private name;
private readonly clock;
private readonly entities;
private readonly isLoading;
private readonly changedEvent;
private readonly errorEvent;
private readonly loadingEvent;
private show;
private clustering;
/**继承DataSource属性end */
/**
*
* @memberof StaticMapBox
*/
visible: boolean;
/**
*
*/
private remove;
/**
*
* @param options
*/
reSet(options: StaticMapBoxOpt): void;
/**
*
* @param west 西0
* @param south 0
* @param east 0
* @param north 0
* @param level ,3
* @param heightLevel
*/
setRange(west: number, south: number, east: number, north: number, heightLevel?: number, level?: number): void;
/**设置网格剖分层次 */
setLevel(level: number): void;
/**设置网格径向(高度维)剖分层次 */
setHeightLevel(heightLevel: number): void;
/**
*
* @param relativeHeight
*/
setRelativeHeight(relativeHeight: number): void;
/**
*
* @param height
* extrudedHeight可以直接赋值也可由height + relativeHeight求得
*/
setHeight(height: number): void;
/**
*
* @param extrudedHeight
* extrudedHeight可以直接赋值也可由height + relativeHeight求得
*/
setExtrudedHeight(extrudedHeight: number): void;
/**
*
* @param outlineColor
*/
setOutlineColor(outlineColor: string): void;
/**
*
* @param color
*/
setColor(color: string): void;
/**
*
*/
backToDefault(): void;
/**
* DQG网格初始化
* @param tileList
* @param cameraInfo
* @param rect
*/
private initialstaticTileUpdate;
/**
*
*/
private staticTileUpdate;
/**
*
* @param time
*/
private update;
/** 销毁函数 */
destroy(): void;
}
class StaticMapBoxOpt {
/** 矩形西边框经度 */
west: number;
/** 矩形南边框经度 */
south: number;
/** 矩形东边框经度 */
east: number;
/** 矩形北边框经度 */
north: number;
/** 要剖分的网格层级 */
level?: number;
/** 网格单元体自身的高度等于extrudedHeight - height */
relativeHeight?: number;
/** 网格单元底面距椭球面高度 */
height?: number;
/** 网格单元挤压面距离椭球面的高度 */
extrudedHeight?: number;
/** 径向(高度维)上的网格层级 */
heightLevel?: number;
/** 网格边框颜色 */
outlineColor?: string;
/** 网格体颜色 */
color?: string;
/** 实体网格是否单独绘制每个网格体默认false 若为true可能会影响绘制效率 */
isDrawEachGrid?: boolean;
}
/**
* -
* GeoCanvas时自动在SceneOptions类进行实例化
* 使SceneOptions类说明
*/
class Weather {
private viewer;
fog: Fog;
rain: Rain;
snow: Snow;
constructor(viewer: Cesium.Viewer);
/**
*
*/
displayHeight: number;
private calculateCamera;
private _rain;
private _snow;
/**
*
*/
showRain(): void;
/**
*
*/
closeRain(): void;
private getRainShader;
/**
*
*/
showSnow(): void;
/**
*
*/
closeSnow(): void;
private getSnowShader;
/**
*
*/
showFog(): void;
/**
*
*/
closeFog(): void;
}
class GM26400 {
/**
* 180
* @param controlPoints
*/
static modifyControlPoints(controlPoints: Array<GeoPoint>): void;
static distance(p1: GeoPoint, p2: GeoPoint): number;
static getAngle(p1: GeoPoint, p2: GeoPoint): number;
/**
* X符号
* @param p X中心点
* @param angle
* @param symbol_len
* @param results
*/
static getXCoords(p: GeoPoint, angle: number, symbol_len: number, results?: Array<GeoPoint>): Array<GeoPoint>;
/**
*
* @param p
* @param angle
* @param length
* @param dir
* @param results
*/
static getArraw(p: GeoPoint, angle: number, length: number, dir: boolean, results?: Array<GeoPoint>): Array<GeoPoint>;
static toVertice_Alg1(pts: Array<GeoPoint>, numArray: Array<number>): Array<GeoPoint> | undefined;
static toVertice_Alg2(pts: Array<GeoPoint>, numArray: Array<number>): Array<GeoPoint> | undefined;
static toVertice_Alg3(pts: Array<GeoPoint>, numArray: Array<number>): Array<GeoPoint> | undefined;
static toVertice_Alg4(pts: Array<GeoPoint>, numArray: Array<number>): Array<GeoPoint> | undefined;
static toVertice_Alg5(pts: Array<GeoPoint>, numArray: Array<number>): Array<GeoPoint> | undefined;
static toVertice_Alg6(pts: Array<GeoPoint>, numArray: Array<number>): Array<GeoPoint> | undefined;
static toVertice_Alg7(pts: Array<GeoPoint>, numArray: Array<number>): Array<GeoPoint> | undefined;
/**
* @param code
* @param positions
*/
static getPositionsByCode(code: string, positions: Array<GeoPoint>): any;
}
/// <reference path="../../../src/Types/cesium.d.ts" />
class BuildGeometry {
private _slice;
private _circlePts;
constructor();
/**
*
* @param slice
*/
private buildCircle;
/**
*
* @param slice 60
*/
getCircleVertex(slice?: number): Cartesian2[];
/**
*
*/
getSlice(): number;
/**
* Triangle构建的圆geometry对象primitive中可设置modelMatrix参数
* @param r
* @param offsetPos Triangle绘制不出来
* @param slice 60
*/
createCircleGeometry_Triangles(r: number, offsetPos?: Cesium.Cartesian3, slice?: number): Cesium.Geometry;
/**
* Triangle构建的圆geometry对象2D显示专用
* @param center
* @param r
* @param slice 60
*/
createCircleGeometry2D_Triangles(center: GeoPoint, r: number, slice?: number): Cesium.Geometry;
/**
* geometry对象
* @param r
* @param m
* @param offsetPos Triangle绘制不出来
* @param slice 60
*/
createCircleGeometry_Polygon(r: number, m: Cesium.Matrix4, offsetPos?: Cesium.Cartesian3, slice?: number): any;
/**
* geometry对象
* @param topRadius
* @param bottomRadius
* @param height
* @param slice 60
* @param useNormals 线true,线
*/
createTruncatedConeGeometry(topRadius: number, bottomRadius: number, height: number, slice?: number, useNormals?: boolean): Cesium.Geometry;
}
/**
* @类别 </br>
* @描述 </br>
* @see <a href='../../../examples/gallery/editor.html#spaceDis'></a>
* @see <a href='../../../examples/gallery/editor.html#paowu'>线</a>
*
*/
class Calculate {
/**
* 18000
*/
static modifyControlPoints(controlPoints: Array<GeoPoint>, result?: Array<GeoPoint>): GeoPoint[];
/**
* 姿姿
* +姿WGS84椭球体坐标系
* XYZ+姿
* object对象{position,heading,pitch,roll}
* ```
* :
* let parent = {
* position: new GV.GeoPoint(114, 32, 10000),
* roll: 5,
* heading: 60,
* pitch: -40
* };
* let child = {
* x: 0.5,
* y: -0.2,
* z: -0.8,
* roll: -5,
* heading: 30,
* pitch: 0
* };
* let res = Calculate.calculateMatrix(parent, child);
* //将计算的结果应用到cylinderGraphic标绘对象
* cylinderGraphic.position = res.position;
* cylinderGraphic.heading = res.heading;
* cylinderGraphic.pitch = res.pitch;
* cylinderGraphic.roll = res.roll;
* ```
*/
static calculateMatrix(parentGesture: any, childGesture: any): {
position: GeoPoint;
heading: number;
pitch: number;
roll: number;
};
/**
* 姿
* object对象{position,heading,pitch,roll}
* ```
* :
*
* ```
*/
static matrixToHdr(uMMatrix: Cesium.Matrix4): {
position: GeoPoint;
heading: number;
pitch: number;
roll: number;
};
private static _surfaceDistance;
private static _getAngle;
private static _getBearing;
/**
*
* @param geoPoints
* @return
* ```
*
* let geoPoints = [{lon:80,lat:50,alt:50000},{lon:90,lat:45,alt:50000},{lon:85,lat:30,alt:50000}]
* let result = GV.Calculate.spaceArea(geoPoints);
* ```
*/
static spaceArea(geoPoints: Array<GeoPoint>): number;
/**
*
* @param pt
* @param distance
* @param bearing 090
* @return
* ```
*
* let geoPoint = new GeoPoint(120, 26);
* let result = GV.Calculate.rhumbDestination(geoPoint, 3000, 90);
* ```
*/
static rhumbDestination(pt: GeoPoint, distance: number, bearing: number, options?: {
units: string;
}): GeoPoint;
/**
*
* @param geoPoints
* @return
* ```
*
* let geoPoints = [{lon:80,lat:50,alt:50000},{lon:90,lat:45,alt:50000},{lon:85,lat:30,alt:50000}]
* let result = GV.Calculate.groundArea(geoPoints);
* ```
*/
static groundArea(geoPoints: Array<GeoPoint>): number;
/**
*
* @param geoPoints
* @param viewer
* @return
* ```
*
* let geoPoints = [{lon:80,lat:50,alt:50000},{lon:90,lat:45,alt:50000},{lon:85,lat:30,alt:50000}]
* let result = GV.Calculate.groundDistance(geoPoints);
* ```
*/
static groundDistance(geoPoints: Array<GeoPoint>, viewer: Cesium.Viewer): number;
/**
*
* @param geoPoints
* @return
* ```
*
* let geoPoints = [{lon:80,lat:50,alt:50000},{lon:90,lat:45,alt:50000},{lon:85,lat:30,alt:50000}]
* let result = GV.Calculate.spaceDistance(geoPoints);
* ```
*/
static spaceDistance(geoPoints: Array<GeoPoint>): number;
/**
* 线
* @param geoPoints
* @param step 100 >=2 && <= 100
* @return
* ```
*
* let geoPoints = [{lon:80,lat:50,alt:50000},{lon:90,lat:45,alt:50000},{lon:85,lat:30,alt:50000}]
* let result = GV.Calculate.getBezier(geoPoints);
* ```
*/
static getBezier(geoPoints: Array<GeoPoint>, step?: number): Array<GeoPoint>;
/**
* 线
* @param fromPoint
* @param toPoint
* @param factor 线>=1000 && <= 10000000
* @param step 100 >=2 && <= 100
* ```
*
* let result = GV.Calculate.getParabola({lon:80,lat:50,alt:50000},{lon:90,lat:45,alt:50000},50000);
* ```
*/
static getParabola(fromPoint: GeoPoint, toPoint: GeoPoint, factor: number, step?: number): any[];
/**
*
* @param point
* @param polygon
* @returns
* @see <a href='../../../examples/gallery/editor.html#simlarScene'></a>
*/
static pointInPolygon(point: GeoPoint, polygon: Array<GeoPoint>): boolean;
/**
*
* @param point
* @param centerPoint
* @param radius
* @returns
* @see <a href='../../../examples/gallery/editor.html#simlarScene'></a>
*/
static pointInCircle(point: GeoPoint, centerPoint: GeoPoint, radius: number): boolean;
/**
* 线
* @param point
* @param lineStart 线
* @param lineEnd 线
* @returns true:线;false:线
*/
static pointOnLine(point: GeoPoint, lineStart: GeoPoint, lineEnd: GeoPoint): boolean;
/**
*
* @param center
* @param xSemiAxis
* @param ySemiAxis
* @param steps 45
* @returns
* @see <a href='../../../examples/gallery/editor.html#polygonDiff'></a>
*/
static getEllipsePositions(center: GeoPoint, xSemiAxis: number, ySemiAxis: number, steps?: number): GeoPoint[];
/**
*
* @param center
* @param radius
* @param steps
* @returns
* @see <a href='../../../examples/gallery/editor.html#polygonDiff'></a>
*/
static getCirclePositions(center: GeoPoint, radius: number, steps?: number): GeoPoint[];
/**
* startAngle和endAngle之间0
* @param center
* @param radius
* @param startAngle
* @param endAngle
* @param steps 64
* @returns
*/
static getSectorPositions(center: GeoPoint, radius: number, startAngle?: number, endAngle?: number, steps?: number): GeoPoint[];
/**
*
* @param polygon1
* @param polygon2
* @returns undefined()
* @see <a href='../../../examples/gallery/editor.html#polygonDiff'></a>
*/
static getIntersect(polygon1: Array<GeoPoint>, polygon2: Array<GeoPoint>): Array<GeoPoint>;
/**
*
* @param polygon1
* @param polygon2
* @returns object对象{type: 'Polygon', geometry: [[GeoPoint,GeoPoint,...], [GeoPoint,GeoPoint,...], ...]};
* type属性为'Polygon'/(geometry的数值长度大于1)type属性为'MultiPolygon'
* @see <a href='../../../examples/gallery/editor.html#polygonDiff'></a>
*/
static getUnion(polygon1: Array<GeoPoint>, polygon2: Array<GeoPoint>): {
type: string;
geometry: {};
};
/**
*
* @param polygon1
* @param polygon2
* @returns undefined
* @see <a href='../../../examples/gallery/editor.html#polygonDiff'></a>
*/
static getDiffer(polygon1: Array<GeoPoint>, polygon2: Array<GeoPoint>): Array<GeoPoint>;
/**
*
* @param point1
* @param point2
* @return
*/
static getAngle(point1: GeoPoint, point2: GeoPoint): number;
/**
*
* @param point1 {x:10,y:10}
* @param point2 {x:20,y:20}
*/
static getScreenAngle(point1: {
x: number;
y: number;
}, point2: {
x: number;
y: number;
}): number;
/**
*
* @param point
* @param viewer
*/
static pointInEarthSide(point: GeoPoint, viewer: GeoCanvas): boolean;
/**
* ,4
* @param posArr [[0.0, 0.0],[20.0, 10.0],[0.0, 33.0],[0.0, 0.0]]
*/
static centerOfMass(posArr: Array<Array<number>>): GeoPoint;
/**
*
* @param allPolygon
* @param resPolygon
* @return resArray Array
*/
static getUnions(originAllPolygon: any, resPolygon?: any): void;
}
/**
* @类别 </br>
* @描述 Canvas转换成各种图片工具库</br>
* @see <a href='../../../examples/gallery/editor.html#screenShot'></a>
*/
class Canvas2Image {
private static support;
private static downloadMime;
private static scaleCanvas;
private static getDataURL;
private static saveFile;
private static genImage;
private static fixType;
private static encodeData;
private static getImageData;
private static makeURI;
/**
* create bitmap image
*
*/
private static genBitmapImage;
/**
* saveAsImage
* @param canvasElement
* @param {String} image type
* @param {Number} [optional] png width
* @param {Number} [optional] png height
*/
private static saveAsImage;
private static convertToImage;
/**
* png格式
* @param canvas dom元素
* @param {number} width
* @param {number} height
* ```
*
* const ratio = viewer.canvas.width / viewer.canvas.height;
* const img = GV.Canvas2Image.saveAsPNG(viewer.canvas, 400, 400 / ratio)
* ```
*/
static saveAsPNG(canvas: Element, width: number, height: number): void;
/**
* jpeg格式
* @param canvas dom元素
* @param {number} width
* @param {number} height
* ```
*
* const ratio = viewer.canvas.width / viewer.canvas.height;
* const img = GV.Canvas2Image.saveAsJPEG(viewer.canvas, 400, 400 / ratio)
* ```
*/
static saveAsJPEG(canvas: Element, width: number, height: number): void;
/**
* gif格式
* @param canvas dom元素
* @param {number} width
* @param {number} height
* ```
*
* const ratio = viewer.canvas.width / viewer.canvas.height;
* const img = GV.Canvas2Image.saveAsGIF(viewer.canvas, 400, 400 / ratio)
* ```
*/
static saveAsGIF(canvas: Element, width: number, height: number): void;
/**
* bmp格式
* @param canvas dom元素
* @param {number} width
* @param {number} height
* ```
*
* const ratio = viewer.canvas.width / viewer.canvas.height;
* const img = GV.Canvas2Image.saveAsBMP(viewer.canvas, 400, 400 / ratio)
* ```
*/
static saveAsBMP(canvas: Element, width: number, height: number): void;
/**
* png格式
* @param canvas dom元素
* @param {number} width
* @param {number} height
* @return base64数据
* ```
*
* const ratio = viewer.canvas.width / viewer.canvas.height;
* const img = GV.Canvas2Image.convertToPNG(viewer.canvas, 400, 400 / ratio)
* ```
*/
static convertToPNG(canvas: Element, width: number, height: number): string;
/**
* jpeg格式
* @param canvas dom元素
* @param {number} width
* @param {number} height
* @return base64数据
* ```
*
* const ratio = viewer.canvas.width / viewer.canvas.height;
* const img = GV.Canvas2Image.convertToJPEG(viewer.canvas, 400, 400 / ratio)
* ```
*/
static convertToJPEG(canvas: Element, width: number, height: number): string;
/**
* gif格式
* @param canvas dom元素
* @param {number} width
* @param {number} height
* @return base64数据
* ```
*
* const ratio = viewer.canvas.width / viewer.canvas.height;
* const img = GV.Canvas2Image.convertToGIF(viewer.canvas, 400, 400 / ratio)
* ```
*/
static convertToGIF(canvas: Element, width: number, height: number): string;
/**
* bmp格式
* @param canvas dom元素
* @param {number} width
* @param {number} height
* @return base64数据
* ```
*
* const ratio = viewer.canvas.width / viewer.canvas.height;
* const img = GV.Canvas2Image.convertToBMP(viewer.canvas, 400, 400 / ratio)
* ```
*/
static convertToBMP(canvas: Element, width: number, height: number): string;
/**
* svg格式
* @param canvas dom元素
* @return svg字符串
* ```
*
* const svgStr = GV.Canvas2Image.convertToSvg(viewer.canvas)
* ```
*/
static convertToSvg(canvas: HTMLCanvasElement): string;
/**
*
* @param src
* @param fileName .jpeg
*/
static downloadImg(src: string, fileName: string): void;
}
/**
* @类别 </br>
* @描述 </br>
*/
class Check {
/**
*
* @param value
* @return true or false
* ```
*
* let res = GV.Check.isBoolean(false);
* ```
*/
static isBoolean(value: any): boolean;
/**
* json对象
* @param value
* @return true or false
*/
static isJson(value: any): boolean;
/**
*
* @param value
* @return true or false
*/
static isString(value: any): boolean;
/**
*
* @param value
* @return true or false
*/
static isNumber(value: any): boolean;
/**
*
* @param value
* @return true or false
*/
static isArray(value: any): boolean;
/**
*
* @param value
* @return true or false
*/
static isCssColor(value: any): boolean;
}
/**
* @类别
* @描述
*/
class ColorTable {
static colorRgb(sColor: any): any;
static colorHex(rgb: any): any;
/**
* @name:
* @msg: hex颜色格式
* @param {startColor} String hex格式
* @param {endColor} String hex格式
* @param {step} Number
* @return Array<string>
*/
static getColorRamp(startColor: String, endColor: String, step: number): Array<String>;
/**
* @name: rgb颜色转换
* @param {color} String rgb格式
* @return String
*/
static colorRGBtoHex(color: any): String;
}
/**
* @类别 使
* @描述
* @see <a href='../../../examples/gallery/editor.html#compoundImage'></a>
*/
class CompoundImage {
/**
* 23
*/
private static _level;
/**
* dpi
*/
private static _dpi;
/**
* @ignore
*
* */
private static _originItem;
/**
* @ignore
*
* */
private static viewer;
/**
* @ignore
*
* */
private static _doCaptcher;
/**
* @ignore
* base64
* */
private static _originSrc;
/**
* @ignore
*
*/
private static _selectGeoPoint;
/**
* @ignore
* base64
* */
private static _resSrc;
/**
* @ignore
*
* */
private static _isDoingCaptcher;
/**
* @ignore
*
* */
private static _autoTimer;
/**
* @ignore
*
*/
private static _delay;
/**
* @ignore
* Promise resolve reject
*/
private static resolve;
private static reject;
/**
* @ignore
* @param hdvImageOpt
*
*/
private static hdvImgData;
/**
*
* @param hdvImageOpt
* @描述 Promise, base641
*
* ```
* let imgPromise = GV.CompoundImage.createHDVImage({
* viewer: viewer,
startPoint: [10,10]
endPoint:[100, 100]
* })
* if(imgPromise){
* imgPromise
* .then(img => {
// img 为 base64 结果
}).catch(()=>{
alert('异常中断或停止制图~')
})
* }
* ```
*/
static createHDVImage(hdvImageOpt: HDVImageOption): Promise<HDVImageData>;
/**
* @描述 ,,; autoCaptcher next
* @param startX x
* @param startY y
* @param endX x
* @param endY y
* ```
*
* compond.start(10,50,100,200,(imgSrc)=>{
* // imgSrc 取到高清制图结果的 base64
* console.log(imgSrc)
* })
* ```
*/
private static start;
/**
* @ignore
* @param {
* src: Array,
* width: number,
* height: number,
* picWidth: number,
* picHeight: number,
* } options
* @param {Function} callback img base64
*
* @notes :
*/
private static _pictureFuse;
/**
* @描述
*/
private static next;
/**
* @描述
* @param delay
*/
private static autoCaptcher;
/**
* @描述
*/
static stop(): void;
/**
* @ignore
* @描述
*/
private static _recoverItem;
}
/**
*
*/
class HDVImageData {
/**
* base64
*/
image: string;
/**
*
*/
originImg: string;
/**
*
*/
width: number;
/**
*
*/
height: number;
/**
* dpi
*/
dpi: number;
/**
* 西
*/
rectangle: Array<number>;
/**
*
*/
selectGeoPoint: Array<GeoPoint>;
}
class HDVImageOption {
/**
*
*/
viewer: GeoCanvas;
/**
* [x,y] -> [0,0]
*/
startPoint: Array<number>;
/**
* [x,y] -> [0,0]
*/
endPoint: Array<number>;
/**
* , 2^n 2
*/
level?: number;
/**
* dpi 96
*/
dpi?: number;
/**
* ms
*/
delay?: number;
}
class encryptUtil {
static Decrypt(word: any): any;
static Encrypt(word: any): any;
static IsValidDate(str: any): boolean;
}
/**
*
*/
class FirstPersonControl {
private startTime;
private endTime;
private currentTime;
private pathArr;
private viewer;
private samplePtProperty;
private handler;
private mousePosition;
private startMousePosition;
private mouseFlag;
private duration;
private dtTime;
/**
*
* @param viewer
* @param path
* @param duration
*/
constructor(viewer: Cesium.Viewer, path: Array<Cesium.Cartesian3>, duration?: number);
/**
*
*/
private init;
/**
*
* camera.flyTo等异步方法造成计算摄像机初始姿态错误
*/
calculateCamera(): void;
/**
*
*/
private controlCamera;
private getFlagForKeyCode;
/**
*
*/
private update;
/**
* {lon:104, lat:33, alt:15139621}
*/
clear(): void;
}
/**
* @类别
* @描述 GeoPoint经纬度坐标对象</br>
*
*/
class GeoPoint {
/**
*
*/
lon: number;
/**
*
*/
lat: number;
/**
*
*/
alt?: number;
constructor(lon: number, lat: number, alt?: number);
toJson(): number[];
add(p: GeoPoint): void;
subtract(p: GeoPoint): void;
multiply(v: number): void;
normalize(): void;
static add(p1: GeoPoint, p2: GeoPoint, res?: GeoPoint): GeoPoint;
static subtract(p1: GeoPoint, p2: GeoPoint, res?: GeoPoint): GeoPoint;
static multiply(p: GeoPoint, v: number, res?: GeoPoint): GeoPoint;
private static _transformlat;
private static _transformlng;
/**
* Cartesian3坐标转GeoPoint
* @param Cart3Point
* @return
* ```
*
* let geoPoint = GV.GeoPoint.fromCartesian3(new Cesium.Cartesian3(8065, 3650, 150000))
* ```
*/
static fromCartesian3(Cart3Point: Cesium.Cartesian3): GeoPoint;
/**
* GeoPointCartesian3坐标
* @param geoPoint
* @return
* ```
*
* let cart3 = GV.GeoPoint.toCartesian3({lon:80,lat:40,alt:50000})
* ```
*/
static toCartesian3(geoPoint: GeoPoint): Cesium.Cartesian3;
/**
* GeoPoint
* @param x
* @param y
* @return
* ```
*
* let geoPoint = GV.GeoPoint.fromMercator(8905559.263461886, 4865942.279503175)
* ```
*/
static fromMercator(x: number, y: number): GeoPoint;
/**
* GeoPoint
* @param geoPoint
* @return
* ```
*
* let mct = GV.GeoPoint.toMercator({lon:80,lat:40,alt:50000})
* ```
*/
static toMercator(geoPoint: GeoPoint): object;
/**
* GeoPoint
* @param x x轴坐标
* @param y y轴坐标
* @param viewer
* @return
* ```
*
* let mct = GV.GeoPoint.fromScreen(50,40,viewer)
* ```
*/
static fromScreen(x: number, y: number, viewer: Cesium.Viewer): GeoPoint;
/**
* GeoPoint
* @param geoPoint
* @param viewer
* @return
* ```
*
* let cart2 = GV.GeoPoint.toScreen({lon:8,lat:40,alt:5000},viewer)
* ```
*/
static toScreen(geoPoint: GeoPoint, viewer: Cesium.Viewer): Cesium.Cartesian2;
/**
* GeoPoint
* @param gcjPoint {x:y:}
* @return
* ```
*
* let geoPoint =  GV.GeoPoint.fromGCJ02({x:8.013949658676198, y:39.99879386130122})
* ```
*/
static fromGCJ02(gcjPoint: any): GeoPoint;
/**
* GeoPoint
* @param geoPoint
* @return
* ```
*
* let gcj = GV.GeoPoint.toGCJ02({lon:8,lat:40,alt:5000});
* ```
*/
static toGCJ02(geoPoint: GeoPoint): object;
/**
* geoPoint转换成数组
* @param geoPoint
* @return
* ```
*
* let res = GV.GeoPoint.pack({lon:8,lat:40,alt:5000})
* ```
*/
static pack(geoPoint: GeoPoint): Array<number>;
/**
* geoPoint
* @param arr
* @return
* ```
*
* let res = GV.GeoPoint.unpack([50,45,1555])
* ```
*/
static unpack(arr: any): GeoPoint;
/**
* geoPoint转换成数组
* @param geoPoints
* @return
* ```
*
* let res = GV.GeoPoint.packArray([{lon:8,lat:40,alt:5000},{lon:45,lat:30,alt:55}])
* ```
*/
static packArray(geoPoints: Array<GeoPoint>): Array<Array<number>>;
/**
* geoPoint
* @param arr
* @return
* ```
*
* let res = GV.GeoPoint.unpackArray([[50,45,1555],[22,54,4545]])
* ```
*/
static unpackArray(arr: any): Array<GeoPoint>;
/**
*
* @param point1
* @param point2
*/
static isEqual(point1: GeoPoint, point2: GeoPoint): boolean;
/**
*
* @param arr1
* @param arr2
*/
static isEqualArr(arr1: Array<GeoPoint>, arr2: Array<GeoPoint>): boolean;
/**
*
*/
static clone(point: GeoPoint, res?: GeoPoint): GeoPoint;
/**
*
* @param value
*/
private static _formatDegree;
/**
*
* @param value
*/
private static _degreeConvertBack;
/**
*
* @param point
*/
static formatDegree(point: GeoPoint): FormatGeoPoint;
static degreeConvertBack(value: FormatGeoPoint): GeoPoint;
}
/**
*
*/
class FormatGeoPoint {
/**
*
*/
lon: {
direction: string /**方位 west 或 east*/;
degrees: number /**度 */;
minutes: number /**分 */;
seconds: number; /**秒 */
};
/**
*
*/
lat: {
direction: string /**方位 south 或 north*/;
degrees: number /**度 */;
minutes: number /**分 */;
seconds: number; /**秒 */
};
}
/**
* x/y的值为偏移的像素值或百分比
*/
let ViewOffset: {
x: number | string;
y: number | string;
};
/**
* @ignore
* @description:
* @param {number} pos
* @param {string} axis "x""y"
* @return {number}
*/
function getOffsetedPosition(pos: number, axis: string): number;
/**
* @类别
* @描述
*/
class Path {
private _id;
private _callback;
private _pathPositions;
private _startTime;
private posProperty;
private _endTime;
private _onStop;
private _doneStopAction;
private _actions;
private _viewer;
private _pathManager;
constructor(viewer: Cesium.Viewer | GeoCanvas, startTime?: Cesium.JulianDate);
readonly id: string;
/**
* @name:
* @msg:
* @param {JulianDate} startTime
* @return {*}
*/
startTime: Cesium.JulianDate;
readonly endTime: Cesium.JulianDate;
/**
*
*/
pathPositions: Array<{
point: GeoPoint;
time: number;
}>;
pathManager: PathManager;
/**
*
*
*/
onStop: any;
private _init;
pathFun: (currentTime: any) => void;
/**
* @name:
* @msg:
* @param {*}
* @return {*}
*/
bindCamera(action: Action["cameraMove"]): void;
/**
* @name:
* @msg:
* @param {*} graphic // 绑定的图形对象
* @param {*} relativePosParam // 相对位置参数
* @param {*} action // 绑定的图形对象所要执行的动作
*/
bindGraphic(graphic: any, relativePosParam: RelativePosParam, action: Action): void;
private _addAction;
private _doAction;
/**
* @name:
* @msg:
* @param {*} action
* @param {*} pixelSizeParam
* @return {*}
*/
private _changePixelSize;
/**
* @name:
* @msg: rgba颜色格式
* @param {*} action
* @param {*} diluteParam
* @return {*}
*/
private _changeTransparent;
/**
* @name: rgb字符串
* @msg:
* @param {*}
* @return {*}
*/
private _parseRGB;
/**
*
*/
callback: Function;
}
/**
* @name:
*/
interface RelativePosParam {
x: number;
y: number;
z: number;
heading: number;
pitch: number;
roll: number;
}
/**
* @name:
*/
interface Action {
cameraMove?: {
startTime?: number;
endTime?: number;
operation?: string;
isTrack?: boolean;
relativePosParam?: any;
callback?: Function;
}[];
pixelSize?: {
startTime?: number;
endTime?: number;
graphic?: any;
operation?: string;
factor?: number;
}[];
visible?: {
startTime?: number;
endTime?: number;
graphic?: any;
operation?: string;
frequency?: number;
}[];
dilute?: {
startTime?: number;
endTime?: number;
graphic?: any;
operation?: string;
factor?: number;
}[];
move?: {
startTime?: number;
endTime?: number;
graphic?: any;
operation?: string;
relativePosParam?: any;
moveCallback?: Function;
}[];
}
class PathManager {
private _state;
private _pathCollection;
private _startTime;
private _endTime;
private _tickListener;
private _clock;
private _multiplier;
private _viewer;
private _stopCallBack;
private _startCallBack;
private _pauseCallBack;
private _runCallBack;
constructor(viewer: any);
speed: number;
addPath(path: Path): void;
delPath(path: Path): void;
clearPaths(): void;
start(): void;
pause(): void;
reStart(): void;
stop(): void;
setStartCallBack(startCallBack: any): void;
setPauseCallBack(pauseCallBack: any): void;
setRunCallBack(runCallBack: any): void;
setStopCallBack(stopCallBack: any): void;
private _listenerFun;
private _removeTickListener;
calcTimeBound(): void;
}
/**
*
*/
enum PathsStateEnum {
/**
*
*/
NotStart = "notstart",
/**
*
*/
Start = "start",
/**
*
*/
Pause = "pause",
/**
*
*/
Stop = "stop",
/**
*
*/
ReStart = "restart"
}
enum PathModeEnum {
/**
*
*/
Loop = "loop",
/**
*
*/
Single = "single"
}
class Picking {
private _viewer;
private scratchPerspectiveFrustum;
private scratchPerspectiveOffCenterFrustum;
private scratchOrthographicFrustum;
private scratchOrthographicOffCenterFrustum;
private scratchPerspPickingFrustum;
private scratchOrthoPickingFrustum;
private scratchOrthoDirection;
constructor(viewer: Cesium.Viewer);
getPickOrthographicCullingVolume(scene: any, drawingBufferPosition: any, width: any, height: any, viewport: any): any;
getPickPerspectiveCullingVolume(scene: any, drawingBufferPosition: any, width: any, height: any, viewport: any): Cesium.CullingVolume;
getPickCullingVolume(scene: any, drawingBufferPosition: any, width: any, height: any, viewport: any): any;
renderTranslucentDepthForPick(scene: any, drawingBufferPosition: any): void;
/**
* undefined值
* @param x
* @param y
*/
pickCoordinate(x: number, y: number): any;
/**
* undefined值
* @param x
* @param y
*/
pickGeoPoint(x: number, y: number): GeoPoint;
}
/**
* @private
*/
class DateHelper {
static toggleTime(date: Date): string;
static toggleTimeIso(date: Date): string;
static addDate(date: Date, days: any): string;
static getFormatDate(arg: any): string;
static getStrNow(): string;
static getStr(date: Date): string;
private static getTodayZeroDate;
private static getTodayMaxDate;
static getTodayStartStr(): string;
static getTodayEndStr(): string;
static getTomorrowStartStr(): string;
static getTomorrowEndStr(): string;
static getWeekStartStr(): string;
static getWeekEndStr(): string;
static getMonthStartStr(): string;
static getMonthEndStr(): string;
static getYearStartStr(): string;
static getYearEndStr(): string;
static getDate15(): Date;
static getDate60(): Date;
static getDate120(): Date;
static addSecond(data: Date, ss: number): Date;
static addMinutes(data: Date, MM: number): Date;
}
/**
*
*/
class GxMath {
/**
*
* @param x1
* @param y1
* @param x2
* @param y2
* @return
*/
static calculateAngle(x1: any, y1: any, x2: any, y2: any): number;
/**
*
* @param tle1 1'1 25544U 98067A 13149.87225694 .00009369 00000-0 16828-3 0 9031'
* @param tle2 2'2 25544 051.6485 199.1576 0010128 012.7275 352.5669 15.50581403831869'
*/
static calculatePeriod(tle1: string, tle2: string): number;
/**
* ECI坐标
* @param beginTime
* @param tle1 1'1 25544U 98067A 13149.87225694 .00009369 00000-0 16828-3 0 9031'
* @param tle2 2'2 25544 051.6485 199.1576 0010128 012.7275 352.5669 15.50581403831869'
* @param period
* @param cnt
*/
static calculateOrbitEci(beginTime: Date, tle1: string, tle2: string, period?: number, cnt?: number): Array<GeoVector3>;
/**
* Eci位置
* @param t
* @param tle1 1'1 25544U 98067A 13149.87225694 .00009369 00000-0 16828-3 0 9031'
* @param tle2 2'2 25544 051.6485 199.1576 0010128 012.7275 352.5669 15.50581403831869'
*/
static getEciPosition(t: Date, tle1: string, tle2: string): Cesium.Cartesian3;
/**
* ECF坐标
* @param beginTime
* @param tle1 1'1 25544U 98067A 13149.87225694 .00009369 00000-0 16828-3 0 9031'
* @param tle2 2'2 25544 051.6485 199.1576 0010128 012.7275 352.5669 15.50581403831869'
* @param period
* @param cnt
*/
static calculateOrbitEcf(beginTime: Date, tle1: string, tle2: string, period?: number, cnt?: number): Array<GeoVector3>;
/**
* Ecf位置
* @param t
* @param tle1 1'1 25544U 98067A 13149.87225694 .00009369 00000-0 16828-3 0 9031'
* @param tle2 2'2 25544 051.6485 199.1576 0010128 012.7275 352.5669 15.50581403831869'
*/
static getEcfPosition(t: Date, tle1: string, tle2: string): Cesium.Cartesian3;
/**
*
* @param beginTime
* @param tle1 1'1 25544U 98067A 13149.87225694 .00009369 00000-0 16828-3 0 9031'
* @param tle2 2'2 25544 051.6485 199.1576 0010128 012.7275 352.5669 15.50581403831869'
* @param period
* @param cnt
*/
static calculateOrbitGeodetic(beginTime: Date, tle1: string, tle2: string, period?: number, cnt?: number): Array<GeoVector3>;
/**
*
* @param t
* @param tle1 1'1 25544U 98067A 13149.87225694 .00009369 00000-0 16828-3 0 9031'
* @param tle2 2'2 25544 051.6485 199.1576 0010128 012.7275 352.5669 15.50581403831869'
*/
static getGeoPosition(t: Date, tle1: string, tle2: string): GeoPoint;
/**
*
* @param cartesian3
* @param viewer
*/
static getLongitudeByCartesian3(cartesian3: Cesium.Cartesian3, viewer: Cesium.Viewer): number;
/**
*
*/
static getLatitudeByCartesian3(cartesian3: Cesium.Cartesian3, viewer: Cesium.Viewer): number;
/**
*
*/
static getHeightByCartesian3(cartesian3: Cesium.Cartesian3, viewer: Cesium.Viewer): number;
/**
*
* @param cartesian3
* @param height
*/
static getHeightdefineByXYZ(cartesian3: Cesium.Cartesian3, height: number, viewer: Cesium.Viewer): Cesium.Cartesian3;
/**
* event
* @param {screen position from mouse} screenPos
* @private
*/
static screen2lonlat(screenPos: any, viewer: any): number[];
/**
* cesium cartesian
* @param {} lonlat
* @param {} height
* @private
*/
static lonlat2Cartesian(lonlat: any, height?: number): Cesium.Cartesian3;
/**
*
* @private
*/
static lonlathei2Cartesian(lonlathei: any): Cesium.Cartesian3;
/**
*
* @private
*/
static cartesian2lonlat(cartesian: any): number[];
/**
*
* @private
*/
static screen2Cartesian(screenPos: any, height: number, viewer: any): Cesium.Cartesian3;
/**
* @param {* java script date} date
* @Return iso8601 date string like 2012-04-30T12:00:00Z
* @private
*/
static dateToString(date: any): string;
/**
* date日期转换为Julian日期对象date为空
* @param {JulianDate} date
* @private
*/
static julianDate(date?: any): Cesium.JulianDate;
/**
* @private
* @param cart1
* @param cart2
*/
static distance(cart1: any, cart2: any): number;
/**
*
* @private
*/
static cartesian2turfPoint(cartesian: any): any;
/**
*
* @private
*/
static turfGeometry2Cartesians(g: any, height?: number): any;
/**
*
* @private
*/
static deleteEnts(ents: any, viewer: any): void;
}
class SpecularReflection {
private viewer;
private value;
constructor(viewer: Cesium.Viewer);
remove(): void;
add(): void;
destroy(): void;
enabled: Boolean;
static fragmentShader: string;
}
class StatusCheck {
static licTimer: any;
static licDom: any;
private static getData;
static start(): Promise<boolean>;
private static iekey;
static checkFalse(): void;
private static createDom;
static startWebSocket(timeout?: number): Promise<void>;
static isDecodeSuccess(key: any): boolean;
}
class EarthTheme {
/**
* @name:
* @msg:
* @param {string} url xyz瓦片地址
* @return {*}
*/
static getTheme(url?: string): Cesium.UrlTemplateImageryProvider;
}
class SkyboxTheme {
/**
* @name:
* @msg: PositiveXNegativeXPositiveYNegativeYPositiveZNegativeZhd_前缀
* @param {string} url
* @param {boolean} isHD
* @param {string} format
* @return {*}
*/
static getSkyBox(url?: string, isHD?: boolean, format?: string): Cesium.SkyBox;
}
/**
* @类别
* @描述
*/
class Util {
/**
* GEOVIS.web.js的相对路径获得完整资源路径
* @param url GEOVIS.web.js路径
* @return
* ```
*
* let url = GV.Util.formatUrlByBaseJs('./data.png')
* ```
*/
static formatUrlByBaseJs(url: string): string;
private static getBaseUrlFromGEOVISScript;
/**
* id
* @return
*/
static createGuid(): string;
/**
*
* @param a
* @param b
*/
static defaultValue(a: any, b: any): any;
/**
*
* @param originPath
* @param file
*/
static formatURLByCustom(originPath: string, file: string): string;
/**
* html的原始路径与相对路径拼接获得完整路径
* @param file html的相对路径
*/
static formatURL(file: string): string;
/**
* text
* @param path
*/
static syncGetText(path: any): string;
/**
* json数据
*/
static syncGetJson(path: any): any;
static formatURL2(originPath: any, file: any): any;
/**
* html标签转成canvas
* @param container html容器
* @param option
* @param callback
*/
static html2canvas(container: any, option: any, callback?: any): void;
/**
* EPSG3857EPSG4326
* @param x
* @param y
*/
static epsg3857To4326(x: any, y: any): any;
/**
* EPSG4326EPSG3857
* @param lon degree
* @param lat degree
*/
static epsg4326To3857(lon: any, lat: any): any;
/**
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @returns {Cesium.Rectangle} the area Cartographic position
*/
static getRectangleFromcode(level: any, x: any, y: any): Cesium.Rectangle;
/**
*
* @param viewer
* @param {Cartesian} mousePos The screen positon
* @returns {object} the area Cartographic position
* {
"level": 5,
"x": 2,
"y": x,
"resolution":"9公里"
}
*/
static getCodeFromScreenPosition(viewer: any, mousePos: any): {
"level": number;
"x": number;
"y": number;
"resolution": any;
};
/**
*
*/
static PrefixInteger(num: any, n: any): string;
/**
*
* @param {number} lon The geoposition of longitude,in degreee
* @param {number} lat The geoposition of latitude,in degreee
* @param {number} height
* @param {number} dis The distance to the geoposition
* @param {number} angel The angle to the north,in degreee
* @returns {object} the new geoposition ,in degree
* {
"lon": 120.0,
"lat": 30.0
}
*/
static calculateNewGeoposition(viewer: any, lon: any, lat: any, height: any, dis: any, angel: any): {
"lon": number;
"lat": number;
};
/**
* @描述
* @param viewer
* @param src
* @param rectangle [西,,,]
* @returns Promise ImageryProvider
*/
static drawImgToEarth(viewer: any, src: string, rectangle?: Array<number>): Promise<Cesium.ImageryProvider>;
private static _drawOriginImgToEarth;
/**
* @描述
* @param viewer
* @param fromPosition
* @param toPosition
* @returns ,undefined
*/
static intersectionWithTerrain(viewer: Cesium.Viewer, fromPosition: Cesium.Cartesian3, toPosition: Cesium.Cartesian3): Cesium.Cartesian3;
/**
* ()
* @param point
* @param viewer
* @return boolean true
*/
static pointIsVisible(point: GeoPoint, viewer: Cesium.Viewer): boolean;
/**
*
* @param v
* @param decimal
*/
static getPrecision(v: number, decimal?: number): number;
/**
* PBF ArrayBuffer GeoJSON数组数据
* @param data PBF ArrayBuffer
*/
static getGeoJSONFromPbf(data: any, level: any, x: any, y: any): any;
/**
* GET方式获取地址
* @param url
* @param data
*/
static get(url: string): Promise<any>;
/**
* POST方式获取地址
* @param url
* @param data
*/
static post(url: string, data: object): Promise<any>;
/**
*@ignore
*/
private static getCGCSArea;
/**
* 20CGCS2000的每年改正数
* * @param viewer
* @param lon {number}
* @param lat {number}
* @returns {object}
* {
"dx": 0.03,
"dy": 0.01,
"dz": 0.01
}
*/
static toCGCS000(viewer: Cesium.Viewer, lon: number, lat: number): {
"dx": number;
"dy": number;
"dz": number;
};
/**
*
* @param posArray
* @returns {number} 1 -10
*/
static isConvex(posArray: Array<GeoPoint>): 0 | 1 | -1;
/**
* @ignore
*
*/
static clustering: any;
}
/**
* @类别
* @描述
*/
class ViewPoint {
/**
*
*/
lon: number;
/**
*
*/
lat: number;
/**
*
*/
alt: number;
/**
* / : >=0 && <=360 (-30 = 330)
*/
heading: number;
/**
* >=-90 && <=90
*/
pitch: number;
/**
* >=0 && <=360
*/
roll: number;
constructor(lon: number, lat: number, alt?: number, heading?: number, pitch?: number, roll?: number);
/**
* viewPoint转换成数组
* @param viewPoint
* @return
* ```
* :
* let viewPoint = new GV.ViewPoint(100,20,500000)
* let pack = GV.ViewPoint.pack(viewPoint)
* ```
*/
static pack(viewPoint: any): Array<number>;
/**
* viewPoint
* @param arr
* @return
* ```
* :
* let arr = [100,20,500000,-90,0,0]
* let pack = GV.ViewPoint.unpack(arr)
* ```
*/
static unpack(arr: any): ViewPoint;
}
/**
* @类别 </br>
* @描述 GEOVIS Camera </br>
* </br>
* @see <a href='../../../examples/gallery/editor.html#rotate'></a>
* @see <a href='../../../examples/gallery/editor.html#zoom'></a>
* @see <a href='../../../examples/gallery/editor.html#rotateByCurrent'></a>
* @see <a href='../../../examples/gallery/editor.html#pitch'></a>
* @see <a href='../../../examples/gallery/editor.html#fly'></a>
* @see <a href='../../../examples/gallery/editor.html#rotateByPoint'></a>
* @see <a href='../../../examples/gallery/editor.html#flyHome'></a>
*/
class Camera {
private _viewer;
private _viewPoint;
private _home;
private _moveEnd;
private _moveStart;
private _changed;
private _timeExection;
/**
* GeoCanvas后通过viewer.iCamera调用
* ```
*
* let viewer = new GV.GeoCanvas('geoCanvas')
* viewer.iCamera
* ```
*/
constructor(viewer: GeoCanvas);
/**
*
* @return
* ```
*
*viewer.iCamera.moveEnd.addEventListener(function(){
* console.log("moveEnd")
* })
* ```
*/
readonly moveEnd: Cesium.Event;
/**
*
* @return
* ```
*
* viewer.iCamera.moveStart.addEventListener(function(){
* console.log("moveStart")
* })
* ```
*/
readonly moveStart: Cesium.Event;
/**
*
* @return
* ```
*
* viewer.iCamera.changed.addEventListener(function(){
* console.log("changed")
* })
* ```
*/
readonly changed: Cesium.Event;
/**
*
* @return
* ```
*
* let viewPoint = viewer.iCamera.viewPoint;//获取当前相机视角信息
* ```
*/
readonly viewPoint: ViewPoint;
/**
* home视角
* @return
* ```
*
* viewer.iCamera.home = new GV.ViewPoint(104,33,15139621,360,-89,0)//设置home视角信息
* let home = viewer.iCamera.home;//获取home视角信息
* ```
*/
home: ViewPoint;
private _getCameraCenter;
private _getCameraTransform;
/**
*
* @param viewPoint
* @param duration >0 && <=10
* @param completeCallbak
* @param cancelCallback
* @return
* ```
*
* viewer.iCamera.flyTo(new GV.ViewPoint(80,33,5000,360,-89,0),2,function(){
* console.log('complete')
* })
* ```
*/
flyTo(viewPoint: ViewPoint, duration?: number, completeCallbak?: any, cancelCallback?: any): void;
/**
*
* @param minlon
* @param maxlon
* @param minlat
* @param maxlat
* @param duration >0 && <=10
* @param completeCallbak
* @param cancelCallback
* @return
* ```
*
* viewer.iCamera.flyToRect(110,118,30,40,2,function(){
* console.log('complete')
* })
* ```
*/
flyToRect(minlon: number, maxlon: number, minlat: number, maxlat: number, duration?: number, completeCallbak?: any, cancelCallback?: any): void;
/**
* ()
*/
readonly currentLevel: Number;
/**
*
* @return
* ```
*
* viewer.iCamera.flyToHome()
* ```
*/
flyToHome(): void;
/**
*
* @param degree >=-90 && <=90
* @return
* ```
*
* viewer.iCamera.pitch(-30)
* ```
*/
pitch(degree: number): void;
/**
*
* @param degree >=-360 && <=360
* @return
* ```
*
* viewer.iCamera.rotate(-30)
* ```
*/
rotate(degree: number): void;
/**
*
* @param duration s>0 && <= 360
* @return
* ```
*
* viewer.iCamera.lookCenter(20)
* ```
*/
lookCenter(duration?: number): void;
/**
*
* @param geoPoint
* @param duration s >=0 && <=360
* @param distance
* @param pitch
* @return
* ```
*
* viewer.iCamera.lookAround({lon:112,lat:40,alt:50000})
* ```
*/
lookAround(geoPoint: GeoPoint, duration?: number, distance?: number, pitch?: number): void;
/**
*
* @return
* ```
*
* viewer.iCamera.lookStop()
* ```
*/
lookStop(): void;
/**
*
* @param rate >=-360 && <=360
* @return
* ```
*
* viewer.iCamera.zoom(10)
* ```
*/
zoom(rate?: number): void;
}
/**
*
*/
class GeoCanvas extends Cesium.Viewer {
private _sceneOptions;
private _layerManager;
private _camera;
private _analysis;
private _pluginManager;
private _JBConfig;
private _$bus;
/**
* @param {Element} container div元素
* @param {Object} [options]
* @param {String} [options.baseJbUrl]
* @param {String} [options.baseLayerPicker=false]
*/
constructor(container: any, options: any);
private init;
readonly JBConfig: any;
readonly pluginManager: PluginManager;
/**
*
*/
readonly sceneOptions: SceneOptions;
/**
*
*/
readonly layerManager: LayerManager;
/**
*
*/
readonly iCamera: Camera;
/**
*
*/
/**
*
*/
readonly satelliteLayer: SatelliteLayer;
/**
*
*/
readonly graphicLayer: GraphicLayer;
/**
*
*/
readonly imageLayer: ImageLayer;
/**
*
*/
readonly targetLayer: TargetLayer;
/**
*
*/
readonly tileLayer: TileLayer;
/**
*
*/
readonly actionLayer: ActionLayer;
/**
*
*/
readonly analysis: Analysis;
/**
* 齿
* true
*/
fxaa: boolean;
/**
*
* on
* fire
* off
*/
readonly $bus: Event;
destroy(): void;
}
}