/* eslint-disable no-irregular-whitespace */
|
/* eslint-disable no-mixed-spaces-and-tabs */
|
import { Cesium, wutu3d } from '@/global';
|
import { Evented, isArray } from './Event';
|
import {
|
setEntityAttributes,
|
Cartesian3_to_WGS84,
|
getClockViewModel,
|
checkWgs84Point,
|
} from './utils';
|
import { Fence } from './Fence';
|
import * as R from 'ramda';
|
import { Beams } from './Beams';
|
import { DrawOption } from './draw';
|
import { PointCluster } from './Cluster';
|
|
const SINGLE_MAP_IMAGE =
|
'./libs/map/Cesium/Assets/Textures/waterNormalsSmall.jpg';
|
const UI_CHANGE_EVENT = 'ui';
|
|
/**
|
* 地图主类
|
* @extends {Evented}
|
*/
|
export class Map extends Evented {
|
constructor(container, option) {
|
super();
|
this.option = R.merge(
|
{
|
sceneModePicker: false, // 视图模型选择按钮
|
|
fullscreenButton: false, // 全屏按钮
|
|
homeButton: false, // 回到初始化视图按钮
|
|
baseLayerPicker: false, // 底图选择按钮
|
|
navigationHelpButton: false, // 导航工具按钮
|
|
// 底图
|
imageryProvider: null,
|
// 背景色，只有在底图无效的情况下才有用
|
backgroundColor: null,
|
|
// 初始化视图值
|
viewpoint: null,
|
|
// 显示罗盘控件
|
showCompass: false,
|
|
// 当前时间
|
currentTime: undefined,
|
|
// 自定义数据源
|
dataSources: [],
|
},
|
option || {}
|
);
|
|
// 视图控制器
|
const viewer = (this.viewer = this._initViewer(container));
|
|
// 隐藏Cesium官网信息
|
this.viewer._cesiumWidget._creditContainer.style.display = 'none';
|
|
if (!this.option.imageryProvider) {
|
viewer.scene.skyBox = null;
|
viewer.scene.sun.show = false;
|
viewer.scene.moon.show = false;
|
viewer.scene.globe.show = false;
|
viewer.scene.backgroundColor = Cesium.Color.fromCssColorString(
|
this.option.backgroundColor || 'rgba(0, 13, 22, 1)'
|
);
|
viewer.scene.globe.depthTestAgainstTerrain = false;
|
viewer.scene.logarithmicDepthBuffer = false;
|
}
|
|
// 实始化地图初始点
|
this.viewer.camera.flyHome = () => {
|
this.option.viewpoint &&
|
this.setViewpoint(this.option.viewpoint, {
|
duration: 1,
|
});
|
};
|
|
this.viewer.scene.globe.depthTestAgainstTerrain = false;
|
|
// 安装指南针、罗盘插件
|
if (Cesium.viewerCesiumNavigationMixin && this.option.showCompass) {
|
const ops = {};
|
ops.enableCompass = true; //罗盘
|
ops.enableZoomControls = true; //缩放
|
ops.enableDistanceLegend = true; //比例尺
|
ops.enableCompassOuterRing = true; //指南针外环
|
this.viewer.extend(Cesium.viewerCesiumNavigationMixin, ops);
|
}
|
|
// 初始化数据源
|
this._initDataSources();
|
|
// 三维瓦片模型集合
|
this.models = [];
|
this.tileModelCollection = new Cesium.PrimitiveCollection('tilemodel');
|
this.viewer.scene.primitives.add(this.tileModelCollection);
|
|
// 绘制工具
|
this.measureTool = new wutu3d.analysi.Measure({
|
viewer: viewer,
|
removeScreenSpaceEvent: true,
|
label: {
|
font_size: 18,
|
border_width: 4,
|
background: false,
|
},
|
});
|
|
// 绘制工具
|
this.plotDrawTool = new wutu3d.Draw(viewer, { hasEdit: false });
|
|
// 交互
|
this._initEvent();
|
|
this.popups = [];
|
|
// 修改鼠标事件
|
// this.viewer.scene.screenSpaceCameraController.zoomEventTypes = [
|
// Cesium.CameraEventType.WHEEL, Cesium.CameraEventType.PINCH
|
// ];
|
|
// this.viewer.scene.screenSpaceCameraController.tiltEventTypes = [
|
// Cesium.CameraEventType.PINCH, Cesium.CameraEventType.RIGHT_DRAG
|
// ];
|
|
// 视点管理
|
this.viewPoints = [];
|
|
// 漫游
|
this.romas = [];
|
// 漫游工具
|
this._romaTool = new wutu3d.Draw(this.viewer, {
|
hasEdit: true,
|
});
|
|
this.beams = new Beams(this);
|
|
// 实始化地图视点
|
if (this.option.viewpoint) {
|
this.setViewpoint(this.option.viewpoint);
|
}
|
}
|
|
_initDataSources() {
|
this.dataSources = {};
|
this.option.dataSources.forEach(source => {
|
const _source = (this.dataSources[source] = new Cesium.CustomDataSource(
|
source
|
));
|
this.viewer.dataSources.add(_source);
|
});
|
}
|
|
/**
|
* 遍历所有数据源
|
* @param {Function} callback
|
*/
|
eachDataSources(callback) {
|
Object.keys(key => {
|
callback && callback(this.dataSources[key]);
|
});
|
}
|
|
/**
|
* 获取数据源
|
* @param {String} dataSource
|
* @returns Cesium.CustomDataSource
|
*/
|
getDataSource(dataSource) {
|
return this.dataSources[dataSource];
|
}
|
|
/**
|
* 设置数据源可见度
|
* @param {Boolean} visible
|
* @param {String} dataSource 数据源ID，如果不提供，则设置所有对象
|
*/
|
setDataSourceVisible(visible, dataSource) {
|
if (dataSource && this.dataSources[dataSource]) {
|
this.dataSources[dataSource].show = visible;
|
} else if (!dataSource) {
|
this.eachDataSources(ds => {
|
ds.show = visible;
|
});
|
}
|
}
|
|
/**
|
* 清除数据源
|
* @param {String|undefined} 数据源ID，如果不提供，则清空所有数据源
|
*/
|
clearDataSourceEntities(dataSource) {
|
if (dataSource && this.dataSources[dataSource]) {
|
this.dataSources[dataSource].entities.removeAll();
|
} else if (!dataSource) {
|
this.eachDataSources(ds => {
|
ds.entities.removeAll();
|
});
|
}
|
}
|
|
/**
|
* 初始化事件
|
* @private
|
*/
|
_initEvent() {
|
// this.viewer.wutu3d.keyboardRoam.bind({
|
// speedRatio: 150, //平移步长，值越大步长越小。
|
// dirStep: 25, //相机原地旋转步长，值越大步长越小。
|
// rotateStep: 1.0, //相机围绕目标点旋转速率，0.3 - 2.0
|
// minPitch: 0.1, //最小仰角 0 - 1
|
// maxPitch: 0.95, //最大仰角 0 - 1
|
// });
|
this.handler = new Cesium.ScreenSpaceEventHandler(this.viewer.scene.canvas);
|
const viewer = this.viewer;
|
const plotDrawTool = this.plotDrawTool;
|
const _mergeEvt = event => {
|
try {
|
let eventPosition = event.endPosition || event.position;
|
let position1 = viewer.scene.pickPosition(eventPosition);
|
if (position1) {
|
let c = Cesium.Cartographic.fromCartesian(position1); //笛卡尔坐标转为经纬度（弧度）
|
let point = [
|
Cesium.Math.toDegrees(c.longitude),
|
Cesium.Math.toDegrees(c.latitude),
|
c.height,
|
];
|
event.pointWithHeight = point;
|
}
|
|
let position = viewer.camera.pickEllipsoid(
|
eventPosition,
|
viewer.scene.globe.ellipsoid
|
);
|
let pick = viewer.scene.pick(eventPosition);
|
if (
|
Cesium.defined(pick) &&
|
pick.id &&
|
pick.id instanceof Cesium.Entity
|
) {
|
event.entity = pick.id;
|
if (event.entity.attribute && event.entity.attribute.attr) {
|
event.attr = { ...event.entity.attribute.attr };
|
} else {
|
event.attr = null;
|
}
|
} else {
|
event.entity = null;
|
event.attr = null;
|
}
|
event.editPlot = plotDrawTool.getCurrentEntity();
|
event.cartesian3 = position;
|
event.latLngPosition = position && Cartesian3_to_WGS84(position);
|
|
var ray = viewer.camera.getPickRay(eventPosition);
|
let cartesian2 = viewer.scene.globe.pick(ray, viewer.scene);
|
event.latLngPositionGlobe =
|
cartesian2 && Cartesian3_to_WGS84(cartesian2);
|
} catch (e) {}
|
};
|
|
this.handler.setInputAction(evt => {
|
_mergeEvt(evt);
|
this.fire('click', evt);
|
}, Cesium.ScreenSpaceEventType.LEFT_CLICK);
|
|
this.handler.setInputAction(evt => {
|
_mergeEvt(evt);
|
this.fire('mousemove', evt);
|
}, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
|
|
// this.plotDrawTool.on(wutu3d.draw.event.DrawStop, (e) => {
|
// this.fire("drawStop", e);
|
// });
|
|
// this.plotDrawTool.on(wutu3d.draw.event.DrawAddPoint, (e) => {
|
// this.fire("drawUpdate", e);
|
// });
|
|
// this.plotDrawTool.on(wutu3d.draw.event.DrawRemovePoint, (e) => {
|
// this.fire("drawUpdate", e);
|
// });
|
|
// this.plotDrawTool.on(wutu3d.draw.event.EditMovePoint, (e) => {
|
// this.fire("drawUpdate", e);
|
// console.log(e);
|
// });
|
this.handler.setInputAction(evt => {
|
this.fire(UI_CHANGE_EVENT);
|
}, Cesium.ScreenSpaceEventType.WHEEL);
|
this.on(UI_CHANGE_EVENT, e => PointCluster(this, e));
|
}
|
|
/**
|
* 根据模型ID获取模型
|
* @param {String} id 模型ID
|
* @return {Object|undefined}
|
*/
|
getModel(id) {
|
return this.models.filter(d => d.id === id)[0];
|
}
|
|
/**
|
* 定位至模型
|
* @param {String} id 模型ID
|
*/
|
flyToModel(id) {
|
const model = this.getModel(id);
|
if (!model || !model.model) return;
|
this.viewer.flyTo(model.model);
|
}
|
|
/**
|
* 添加模型
|
* @param {String}
|
* @param {Object} param 模型参数
|
* @param {String} param.id 模型ID
|
* @param {String} param.name 模型名称
|
* @param {String} param.link 模型链接地址
|
* @param {String} param.visible 模型可见度
|
* @param {String} param.maximumScreenSpaceError 模型精度，1最高，越大越模糊，默认为4
|
* @param {String} param.modifyZ 模型Z值高度修复，默认为0
|
* @return {Object}
|
*/
|
addModel(option) {
|
if (R.type(option) === 'String') {
|
return this.tileModelCollection.add(
|
new Cesium.Cesium3DTileset({
|
url: option,
|
})
|
);
|
}
|
const {
|
maximumScreenSpaceError,
|
id,
|
name,
|
link,
|
visible,
|
modelMatrix,
|
loaded,
|
focus,
|
color,
|
maximumMemoryUsage,
|
callback,
|
} = option || {};
|
let modifyZ = option.modifyZ;
|
let transform = option.transform;
|
var tileset = this.tileModelCollection.add(
|
new Cesium.Cesium3DTileset({
|
url: link,
|
show: visible === undefined ? true : !!visible,
|
...option,
|
maximumScreenSpaceError: maximumScreenSpaceError || 16,
|
modelMatrix: Cesium.Matrix4.fromArray(
|
modelMatrix || [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
|
),
|
maximumMemoryUsage: maximumMemoryUsage || 1024,
|
})
|
);
|
if (modifyZ && !transform) {
|
transform = { tz: modifyZ };
|
}
|
let _transform = R.merge(
|
{
|
tx: 0.0,
|
ty: 0.0,
|
tz: 0.0,
|
rx: 0.0,
|
ry: 0.0,
|
rz: 0.0,
|
scale: 1.0,
|
},
|
transform || {}
|
);
|
tileset.readyPromise
|
.then(tileset => {
|
var boundingSphere = tileset.boundingSphere;
|
var cartographic = Cesium.Cartographic.fromCartesian(
|
boundingSphere.center
|
);
|
var surface = Cesium.Cartesian3.fromRadians(
|
cartographic.longitude,
|
cartographic.latitude,
|
0.0
|
);
|
var offset = Cesium.Cartesian3.fromRadians(
|
cartographic.longitude,
|
cartographic.latitude,
|
cartographic.height
|
);
|
let lnglat = Cartesian3_to_WGS84(offset);
|
if (transform) {
|
_transform = R.merge(_transform, {
|
tx: _transform.tx || lnglat.x || 0.0,
|
ty: _transform.ty || lnglat.y || 0.0,
|
});
|
tileset._computeTransform = _transform;
|
tileset._root.transform = this.update3dtilesMaxtrix(_transform);
|
} else {
|
tileset._computeTransform = R.merge(
|
{
|
tx: lnglat.x,
|
ty: lnglat.y,
|
tz: lnglat.z,
|
// tz: 0.0,
|
rx: 0.0,
|
ry: 0.0,
|
rz: 0.0,
|
scale: 1.0,
|
},
|
transform || {}
|
);
|
}
|
if (color) {
|
this.setModelColor(tileset, color);
|
}
|
if (focus) {
|
this.viewer.flyTo(tileset);
|
}
|
console.log(1);
|
if (callback) {
|
console.log(callback);
|
callback(tileset);
|
}
|
// viewer.zoomTo(tileset);
|
})
|
.otherwise(function() {});
|
|
tileset.allTilesLoaded.addEventListener(() => {
|
loaded && loaded(tileset);
|
});
|
|
var _model = {
|
...option,
|
name,
|
id: id || Cesium.createGuid(),
|
link: link,
|
model: tileset,
|
visible: visible === undefined ? true : !!visible,
|
modelMatrix: modelMatrix,
|
transform: _transform,
|
maximumScreenSpaceError: maximumScreenSpaceError,
|
};
|
this.models.push(_model);
|
this.fire(UI_CHANGE_EVENT);
|
return _model;
|
}
|
|
removeModels() {
|
this.models.forEach(model => {
|
if (
|
model.model &&
|
model.model instanceof Cesium.Cesium3DTileset &&
|
this.tileModelCollection.contains(model.model)
|
) {
|
this.tileModelCollection.remove(model.model);
|
}
|
});
|
this.models = [];
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
// 设置模型颜色
|
setModelColor(id, color) {
|
const tileset =
|
id instanceof Cesium.Cesium3DTileset
|
? id
|
: this.models.filter(d => d.id === id)[0].model;
|
if (!tileset) return;
|
if (!color) {
|
tileset.style = undefined;
|
} else {
|
tileset.style = new Cesium.Cesium3DTileStyle();
|
tileset.style.color = {
|
evaluateColor: (f, r) => {
|
return Cesium.Color.fromCssColorString(color);
|
},
|
};
|
}
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
// 设置模型位置、旋转角度
|
setModelTransform(id, transform) {
|
if (!transform) return;
|
const model = this.models.filter(d => d.id === id)[0];
|
if (!model) return null;
|
const tileset = model.model;
|
const _transform = R.merge(model.model._computeTransform, transform);
|
this._setTilesetTransform(tileset, _transform);
|
this.fire(UI_CHANGE_EVENT);
|
return this;
|
}
|
|
_setTilesetTransform(tileset, transform) {
|
if (tileset instanceof Cesium.Cesium3DTileset && transform) {
|
tileset._root.transform = this.update3dtilesMaxtrix(transform);
|
this.zoom3dtiles(tileset, transform);
|
return true;
|
}
|
}
|
|
/**
|
* 模型绽放
|
* @param {*} tileset
|
* @param {*} transform
|
* @returns
|
*/
|
zoom3dtiles(tileset, transform) {
|
if (!tileset) return;
|
var scale = (transform.scale || 1) * 1;
|
|
tileset._root.customTransform = {
|
matrix: {
|
origin: tileset._root.transform.clone(),
|
rotation: Cesium.Matrix4.IDENTITY,
|
translation: Cesium.Matrix4.IDENTITY,
|
},
|
};
|
|
var m1 = Cesium.Matrix4.fromScale(
|
new Cesium.Cartesian3(scale, scale, scale)
|
);
|
tileset._root.customTransform.matrix.scale = m1;
|
tileset._root.customTransform.scale = scale;
|
var m2 = new Cesium.Matrix4();
|
Cesium.Matrix4.multiply(
|
tileset._root.customTransform.matrix.origin,
|
tileset._root.customTransform.matrix.rotation,
|
m2
|
);
|
Cesium.Matrix4.multiply(m2, tileset._root.customTransform.matrix.scale, m2);
|
Cesium.Matrix4.multiply(
|
m2,
|
tileset._root.customTransform.matrix.translation,
|
tileset._root.transform
|
);
|
}
|
|
update3dtilesMaxtrix(params) {
|
var mx = Cesium.Matrix3.fromRotationX(Cesium.Math.toRadians(params.rx));
|
var my = Cesium.Matrix3.fromRotationY(Cesium.Math.toRadians(params.ry));
|
var mz = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(params.rz));
|
var rotationX = Cesium.Matrix4.fromRotationTranslation(mx);
|
var rotationY = Cesium.Matrix4.fromRotationTranslation(my);
|
var rotationZ = Cesium.Matrix4.fromRotationTranslation(mz);
|
//平移
|
var position = Cesium.Cartesian3.fromDegrees(
|
params.tx,
|
params.ty,
|
params.tz
|
);
|
var m = Cesium.Transforms.eastNorthUpToFixedFrame(position);
|
//旋转、平移矩阵相乘
|
Cesium.Matrix4.multiply(m, rotationX, m);
|
Cesium.Matrix4.multiply(m, rotationY, m);
|
Cesium.Matrix4.multiply(m, rotationZ, m);
|
return m;
|
}
|
|
//设置模型位置
|
setModelPosition(tileset, lon, lat, alt) {
|
tileset._modelLon = lon || tileset._modelLon;
|
tileset._modelLat = lat || tileset._modelLat;
|
tileset._modelAlt = Cesium.defined(alt) ? alt : tileset._modelAlt;
|
//平移
|
let position = Cesium.Cartesian3.fromDegrees(
|
tileset._modelLon,
|
tileset._modelLat,
|
tileset._modelAlt
|
);
|
let m = Cesium.Transforms.eastNorthUpToFixedFrame(position);
|
//赋值给tileset
|
tileset._root.transform = m;
|
}
|
|
/**
|
* 根据模型ID删除模型
|
* @param {String} id 模型ID
|
* @return this
|
*/
|
removeModel(id) {
|
const model = this.models.filter(d => d.id === id)[0];
|
if (model && model.model) {
|
if (
|
model.model instanceof Cesium.Cesium3DTileset &&
|
this.tileModelCollection.contains(model.model)
|
) {
|
this.tileModelCollection.remove(model.model);
|
}
|
this.models = this.models.filter(d => d.id !== id);
|
}
|
return this;
|
}
|
|
/**
|
* 设置模型可见度
|
* @param {String} id 模型ID
|
* @param {Boolean} visible 可见性
|
* @return this
|
*/
|
setModelVisible(id, visible) {
|
const model = this.models.filter(d => d.id === id)[0];
|
if (model && model.model) {
|
if (model.model instanceof Cesium.Cesium3DTileset) {
|
model.model.show = visible;
|
}
|
for (let i = 0; i < this.models.length; i++) {
|
let md = this.models[i];
|
if (md.id === model.id) {
|
md.visible = visible;
|
}
|
}
|
}
|
return this;
|
}
|
|
/**
|
* 获取视图中心值
|
* @return {Object} {x, y, z, heading, roll, pitch}
|
*/
|
getViewPoint() {
|
const viewer = this.viewer;
|
return wutu3d.point.getCameraView(viewer, true);
|
}
|
|
/**
|
* 设置视图中心
|
* @param {Object} viewpoint {x, y, z, heading, roll, pitch}
|
*/
|
setViewpoint(viewpoint, options) {
|
if (viewpoint) {
|
this.viewer.wutu3d.centerAt(viewpoint, options);
|
}
|
}
|
|
/**
|
* 初始化视图控制器
|
* @private
|
* @param {String|HTMLElement} container 地图DIV容器
|
* @return {Cesium.Viewer}
|
*/
|
_initViewer(container) {
|
const {
|
sceneModePicker,
|
vrButton,
|
baseLayerPicker,
|
fullscreenButton,
|
navigationHelpButton,
|
imageryProvider,
|
homeButton,
|
currentTime,
|
} = this.option;
|
let viewer = new Cesium.Viewer(container || 'map', {
|
geocoder: false,
|
homeButton: homeButton,
|
sceneModePicker: sceneModePicker,
|
fullscreenButton: fullscreenButton,
|
vrButton: vrButton,
|
baseLayerPicker: baseLayerPicker,
|
infoBox: false,
|
selectionIndicator: false,
|
animation: false,
|
timeline: false,
|
shouldAnimate: true,
|
clockViewModel: currentTime ? getClockViewModel(currentTime) : undefined,
|
navigationHelpButton: navigationHelpButton,
|
navigationInstructionsInitiallyVisible: false,
|
imageryProvider:
|
imageryProvider ||
|
new Cesium.SingleTileImageryProvider({
|
url: SINGLE_MAP_IMAGE,
|
}),
|
contextOptions: {
|
webgl: {
|
alpha: true,
|
},
|
},
|
...this.option,
|
dataSources: undefined,
|
});
|
|
viewer.wutu3d = new wutu3d.ViewerEx(viewer, {
|
contextmenu: false,
|
center: this.option.viewpoint || undefined,
|
mouseZoom: false,
|
contextmenuItems: [],
|
});
|
|
return viewer;
|
}
|
|
_plusEntity(entity) {
|
if (!entity) return;
|
let attr = entity.attribute && entity.attribute.attr;
|
let style =
|
entity.attribute && (entity.attribute.style || (attr && attr.style));
|
if (entity.billboard) {
|
entity.billboard.translucencyByDistance = undefined;
|
entity.billboard.disableDepthTestDistance = Number.POSITIVE_INFINITY;
|
entity.billboard.eyeOffset = new Cesium.Cartesian3(0, 0, -10);
|
}
|
if (entity.label) {
|
entity.label.translucencyByDistance = undefined;
|
entity.label.disableDepthTestDistance = Number.POSITIVE_INFINITY;
|
entity.label.eyeOffset = new Cesium.Cartesian3(0, 0, -10);
|
}
|
if (style && attr && attr.animateLine) {
|
entity.polyline.material = new wutu3d.LineFlowMaterial({
|
//动画线材质
|
color: Cesium.Color.fromCssColorString(style.color || '#ff0000'),
|
duration: style.duration || 10000, //时长，控制速度
|
url: style.image || './images/texture/route.png',
|
});
|
}
|
if (style && attr && attr.wave) {
|
entity.ellipse.material = new wutu3d.CircleWaveMaterial({
|
duration: style.duration, //动画时长，单位：毫秒
|
color: Cesium.Color.fromCssColorString(style.color),
|
gradient: style.gradient || 0,
|
count: style.count || 2,
|
});
|
}
|
if (attr && attr.isBeam) {
|
const wgs84PosArr = this.plotDrawTool.getCoordinates(entity)[0];
|
this.beams.add(
|
attr.id || entity.id,
|
{ x: wgs84PosArr[0], y: wgs84PosArr[1] },
|
style
|
);
|
}
|
}
|
|
deltePlotsByKeyValues(queryObject) {
|
const entites = this.queryPlotsByKeyValues(queryObject);
|
entites.forEach(entity => {
|
entity && this.plotDrawTool.deleteEntity(entity);
|
});
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
/**
|
* 查询绘制元素
|
* @param {Object} queryObject
|
* @returns
|
*/
|
queryPlotsByKeyValues(queryObject) {
|
let arrs = [];
|
const keys = Object.keys(queryObject);
|
const entities = this.plotDrawTool.getEntitys();
|
for (let i = 0; i < entities.length; i++) {
|
let entity = entities[i];
|
let attr = entity && entity.attribute && entity.attribute.attr;
|
let flag = true;
|
for (let j = 0; j < keys.length; j++) {
|
let key = keys[j];
|
if (attr[key] !== queryObject[key]) {
|
flag = false;
|
break;
|
}
|
}
|
if (flag) {
|
arrs.push(entity);
|
}
|
}
|
return arrs;
|
}
|
|
/**
|
* 查询元素
|
* @param {*} entities
|
* @param {*} queryObject
|
* @returns
|
*/
|
queryEntitiesByKeyValues(entities, queryObject) {
|
if (!queryObject) return [];
|
let arrs = [];
|
const keys = Object.keys(queryObject);
|
const array = entities._entities._array;
|
for (let i = 0; i < array.length; i++) {
|
let entity = array[i];
|
let attr = entity && entity.attribute;
|
if (!attr) {
|
continue;
|
}
|
let flag = true;
|
for (let j = 0; j < keys.length; j++) {
|
let key = keys[j];
|
if (attr[key] !== queryObject[key]) {
|
flag = false;
|
break;
|
}
|
}
|
if (flag) {
|
arrs.push(entity);
|
}
|
}
|
return arrs;
|
}
|
|
/**
|
* 删除元素
|
* @param {*} entities
|
* @param {*} queryObject
|
*/
|
deleteEntitiesByKeyValues(entities, queryObject) {
|
const targets = this.queryEntitiesByKeyValues(entities, queryObject);
|
targets.forEach(target => {
|
entities.remove(target);
|
});
|
}
|
|
/**
|
* 定位到图标上
|
* @param {*} queryObject
|
* @param {*} option
|
* @returns
|
*/
|
focusMarker(queryObject, option) {
|
if (!queryObject) return;
|
option = option || {};
|
const target = this.queryPlotsByKeyValues(queryObject)[0];
|
if (!target) return;
|
this.viewer.flyTo(target, {
|
duration: 0.5,
|
...option,
|
});
|
}
|
|
/**
|
* 定位到标绘上
|
* @param {*} option Cesium viewer flyTo Options
|
*/
|
flyToPlots(option) {
|
if (this.plotDrawTool.getEntitys().length > 0) {
|
this.viewer.flyTo(this.plotDrawTool.dataSource, {
|
duration: 1,
|
...option,
|
});
|
}
|
return this;
|
}
|
|
/**
|
* 开启编辑
|
* @param {Boolean} editable
|
*/
|
setPlotEditable(editable) {
|
const pt = this.plotDrawTool;
|
pt.hasEdit(editable);
|
if (!editable) {
|
pt.stopDraw();
|
pt.stopEditing();
|
}
|
}
|
|
/**
|
* 是否编辑中
|
*/
|
isPlotEditing() {
|
return this.plotDrawTool._hasEdit;
|
}
|
|
_addLabel(entity, option) {
|
if (!entity || !option || !option.text || !option.showLabel) return;
|
entity.label = new Cesium.LabelGraphics({
|
style: Cesium.LabelStyle.FILL,
|
pixelOffset: new Cesium.Cartesian2(0, (-64 - 10) * option.iconScale),
|
translucencyByDistance: undefined,
|
disableDepthTestDistance: Number.POSITIVE_INFINITY,
|
eyeOffset: new Cesium.Cartesian3(0, 0, -10),
|
showBackground: true,
|
font: '14px Microsoft yahei',
|
backgroundColor: new Cesium.Color(0.0, 0.0, 0.0, 0.8),
|
backgroundPadding: new Cesium.Cartesian2(8, 6),
|
horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
|
verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
|
...option,
|
});
|
}
|
|
/**
|
* 添加图标
|
* @param {Object} option
|
* @returns Cesium.Entity
|
*/
|
addMarker({ text, textStyle, showLabel, icon, iconStyle, attr, wgs84Pos }) {
|
if (!wgs84Pos || !checkWgs84Point(wgs84Pos.x, wgs84Pos.y)) return null;
|
attr = attr || {};
|
showLabel = showLabel === undefined ? true : showLabel;
|
iconStyle = iconStyle || {};
|
const ops = {
|
type: 'billboard',
|
style: {
|
image: icon,
|
...iconStyle,
|
},
|
attr: { id: attr.mac || undefined, type: 'marker', ...attr },
|
};
|
const position = Cesium.Cartesian3.fromDegrees(wgs84Pos.x, wgs84Pos.y);
|
let entity = this.plotDrawTool.attributeToEntity(ops, position);
|
entity.billboard.disableDepthTestDistance = Number.POSITIVE_INFINITY;
|
entity.billboard.eyeOffset = new Cesium.Cartesian3(0, 0, -10);
|
this._addLabel(entity, {
|
showLabel,
|
text,
|
...textStyle,
|
iconScale: iconStyle.scale || 0.5,
|
});
|
this._plusEntity(entity);
|
this.fire(UI_CHANGE_EVENT);
|
return entity;
|
}
|
|
/**
|
* 添加面
|
* @param {Object} option
|
* @returns Cesium.Entity
|
*/
|
addPolygon({ style, attr, wgs84Poss }) {
|
style = style || {};
|
wgs84Poss = wgs84Poss || [];
|
const positions = wgs84Poss.map(wgs84Pos => {
|
let point = wgs84Pos;
|
if (isArray(wgs84Pos)) {
|
point = {
|
x: wgs84Pos[0],
|
y: wgs84Pos[1],
|
z: wgs84Pos[2],
|
};
|
}
|
return Cesium.Cartesian3.fromDegrees(point.x, point.y, point.z || 0);
|
});
|
const entity = this.plotDrawTool.attributeToEntity(
|
{
|
type: 'polygon',
|
style: {
|
...DrawOption.polygon,
|
...style,
|
},
|
attr: {
|
...(attr || {}),
|
},
|
},
|
positions
|
);
|
this._plusEntity(entity);
|
return entity;
|
}
|
|
/**
|
* 添加线
|
* @param {Object} option
|
* @returns Engity
|
*/
|
addPolyline({ attr, style, wgs84Poss }) {
|
style = style || {};
|
wgs84Poss = wgs84Poss || [];
|
const positions = wgs84Poss.map(wgs84Pos => {
|
let point = wgs84Pos;
|
if (isArray(wgs84Pos)) {
|
point = {
|
x: wgs84Pos[0],
|
y: wgs84Pos[1],
|
z: wgs84Pos[2],
|
};
|
}
|
return Cesium.Cartesian3.fromDegrees(point.x, point.y, point.z || 0);
|
});
|
const entity = this.plotDrawTool.attributeToEntity(
|
{
|
type: 'polyline',
|
style: {
|
...DrawOption.polyline,
|
...style,
|
},
|
attr: {
|
...(attr || {}),
|
},
|
},
|
positions
|
);
|
this._plusEntity(entity);
|
return entity;
|
}
|
|
/**
|
* 开始绘制
|
* @param {Object} drawOption 绘制参数，详见说明user.md
|
* @param {Function} callback 绘制完成时加回调
|
*/
|
startDraw(drawOption, callback) {
|
let option = {
|
success: entity => {
|
setEntityAttributes(entity, {
|
id: entity.id,
|
});
|
this._plusEntity(entity);
|
callback && callback(entity);
|
this.fire(UI_CHANGE_EVENT);
|
},
|
...drawOption,
|
};
|
this.plotDrawTool.startDraw(option);
|
}
|
|
/**
|
* 通过代码添加点位
|
* @param {Object} drawOption 绘制选项
|
* @param {Array} position 位置坐标
|
*/
|
createPlot(drawOption, position) {
|
if (
|
!drawOption ||
|
!drawOption.type ||
|
!drawOption.style ||
|
!position ||
|
position[0] === undefined ||
|
position.length < 2
|
)
|
return null;
|
var entity = this.plotDrawTool.attributeToEntity(
|
drawOption,
|
wutu3d.draw.util.lonlat2cartesian([
|
position[0],
|
position[1],
|
position[2] || 0,
|
])
|
);
|
setEntityAttributes(entity, {
|
id: entity.id,
|
});
|
this._plusEntity(entity);
|
return entity;
|
}
|
|
/**
|
* 获取对象
|
* @param {String} id 对象ID
|
*/
|
getPlotById(id) {
|
return this.plotDrawTool.getEntityById(id);
|
}
|
|
/**
|
* 更新对象样式
|
* @param {String} id 对象ID
|
* @param {Object} style 样式对象
|
*/
|
updatePlotStyle(id, style) {
|
if (!id || !style) return;
|
const entity = this.getPlotById(id);
|
if (!entity || !entity.attribute) return;
|
const attribute = entity.attribute;
|
let type = attribute.type;
|
if (type === 'circle') {
|
type = 'ellipse';
|
}
|
if (wutu3d.draw.attr[type]) {
|
wutu3d.draw.attr[type].style2Entity(style, entity[type]);
|
this._plusEntity(entity);
|
}
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
/**
|
* 更新样式属性
|
* @param {String} id 对象ID
|
* @param {Object} attrs
|
*/
|
updatePlotAttribute(id, attrs) {
|
const entity = this.getPlotById(id);
|
setEntityAttributes(entity, attrs);
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
/**
|
* 删除绘制对象
|
* @param {String} id 对象ID
|
*/
|
deletePlot(id) {
|
const entity = this.getPlotById(id);
|
entity && this.plotDrawTool.deleteEntity(entity);
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
/**
|
* 加载GeoJSON
|
* @param {GeoJSON} geojson
|
*/
|
loadGeoJSON(geojson) {
|
this.plotDrawTool.loadJson(geojson);
|
const entities = this.plotDrawTool.getEntitys();
|
for (let i = 0; i < entities.length; i++) {
|
this._plusEntity(entities[i]);
|
}
|
setTimeout(() => {
|
this.fire(UI_CHANGE_EVENT);
|
}, 1000);
|
}
|
|
/**
|
* 将绘制对象转为Geojson数据
|
*/
|
toGeoJSON() {
|
return this.plotDrawTool.toGeoJSON();
|
}
|
|
// 清除所有绘制对象
|
clearAllPlots() {
|
let pt = this.plotDrawTool;
|
pt.stopEditing();
|
pt.clearDraw();
|
pt.deleteAll();
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
addFence(geojson, option) {
|
if (!geojson || !geojson.features) return;
|
if (!this.fenceDataSource) {
|
const dataSource = (this.fenceDataSource = new Cesium.CustomDataSource(
|
'fence'
|
));
|
dataSource.show = true;
|
this.viewer.dataSources.add(dataSource);
|
}
|
option = option || {};
|
|
const color = option.color || '#ff9900';
|
const height = option.height || 50.0;
|
const showDynamic = option.showDynamic;
|
|
let dataSource = this.fenceDataSource;
|
geojson.features.forEach(feature => {
|
const coordinates = feature.geometry.coordinates[0][0];
|
let positions = [];
|
coordinates.forEach(c => {
|
let position = Cesium.Cartesian3.fromDegrees(c[0], c[1], c[2] || 0.5);
|
positions.push(position);
|
});
|
dataSource.fence = new Fence(
|
dataSource,
|
positions,
|
height,
|
Cesium.Color.fromCssColorString(color),
|
showDynamic
|
);
|
});
|
return this.fenceDataSource;
|
}
|
|
rain(enable) {
|
if (enable) {
|
this.rainPost = new Cesium.PostProcessStage({
|
fragmentShader: wutu3d.scene.RainFS,
|
});
|
this.viewer.scene.postProcessStages.add(this.rainPost);
|
} else {
|
this.rainPost &&
|
this.viewer.scene.postProcessStages.remove(this.rainPost);
|
}
|
}
|
|
snow(enable) {
|
if (enable) {
|
this.snowPost = new Cesium.PostProcessStage({
|
fragmentShader: wutu3d.scene.SnowFS,
|
});
|
this.viewer.scene.postProcessStages.add(this.snowPost);
|
} else {
|
this.snowPost &&
|
this.viewer.scene.postProcessStages.remove(this.snowPost);
|
}
|
}
|
|
/**
|
* 获取屏幕中心点三维坐标
|
* @return {Cesium.Cartesian3}
|
*/
|
getScreenCenterPosition() {
|
const { scene, canvas, camera } = this.viewer;
|
const screenPosition = new Cesium.Cartesian2(
|
canvas.width / 2,
|
canvas.height / 2
|
);
|
return scene.globe.pick(camera.getPickRay(screenPosition), scene);
|
}
|
|
_getRomaPathGeometry(roma) {
|
const { path } = roma || {};
|
if (!path || !path.length) return null;
|
const coordinates = path.map(p => p.concat(0.5));
|
return {
|
type: 'FeatureCollection',
|
features: [
|
{
|
type: 'Feature',
|
properties: {
|
type: 'polyline',
|
style: {
|
width: 6,
|
color: 'rgba(255, 255, 0, 0.1)',
|
},
|
},
|
geometry: {
|
type: 'LineString',
|
coordinates: coordinates,
|
},
|
},
|
],
|
};
|
}
|
|
_startDrawRoma(title, callback) {
|
this.stopRoma();
|
const tool = this._romaTool;
|
tool.deleteAll();
|
tool.startDraw({
|
type: 'polyline',
|
style: {
|
width: 6,
|
lineType: 'solid',
|
color: '#ff0000',
|
},
|
success: entity => {
|
const path = tool.toGeoJSON();
|
const _path = path.features[0].geometry.coordinates.map(d =>
|
d.slice(0, 2)
|
);
|
// {id:2, title: "漫游路线2", height:1.5, path: [], speed:1, x: 0, y:0, z:0, type: "gs"},
|
this.addRoma({
|
title: title || '漫游线路' + this.romas.length,
|
path: _path,
|
speed: 1,
|
type: 'dy',
|
height: 1.7,
|
});
|
callback && callback();
|
this.fire(UI_CHANGE_EVENT);
|
},
|
});
|
}
|
|
setRomas(romas) {
|
this.romas = romas;
|
this.fire(UI_CHANGE_EVENT);
|
return this;
|
}
|
|
addRoma({ title, path, speed, x, y, z, type }) {
|
this.romas.push({
|
id: Cesium.createGuid(),
|
title,
|
path,
|
speed,
|
x,
|
y,
|
z,
|
type,
|
});
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
/**
|
* 移除漫游
|
* @param {*} id
|
*/
|
removeRoma(id) {
|
if (id) {
|
if (id === this._currentRoma) {
|
this.stopRoma();
|
}
|
this.romas = this.romas.filter(d => d.id !== id);
|
}
|
this.fire(UI_CHANGE_EVENT);
|
return this;
|
}
|
|
/**
|
* 播放漫游
|
* @param {*} id
|
*/
|
playRoma(id, showPath) {
|
const roma = this.romas.filter(d => d.id === id)[0];
|
if (!roma) return;
|
this.stopRoma();
|
const path = this._getRomaPathGeometry(roma);
|
if (!path) return;
|
if (showPath) {
|
this._romaTool.loadJson(path);
|
}
|
this._currentRoma = roma.id;
|
var flyDataPoints = path.features[0].geometry.coordinates.map(d => {
|
return [d[0], d[1], 1.5];
|
});
|
var flydata = {
|
name: 'plan1',
|
interpolation: false, //是否setInterpolationOptions插值
|
clockLoop: true, //是否循环播放
|
// dy 第一视角, gs 跟随
|
camera: {
|
type: 'dy',
|
followedX: 5,
|
followedZ: 0.5,
|
},
|
points: flyDataPoints,
|
// "clampToGround": true,
|
speed: 16, // km/h
|
};
|
this._romaFlyline = new wutu3d.FlyLine(this.viewer, flydata);
|
this._romaFlyline.start();
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
/**
|
* 停止漫游
|
*/
|
stopRoma() {
|
if (this._romaFlyline) {
|
this._romaFlyline.stop();
|
}
|
this._currentRoma = null;
|
this.fire(UI_CHANGE_EVENT);
|
}
|
|
/**
|
* 开启或关闭阴影
|
* @param {Boolean} enable
|
*/
|
setShadows(enable) {
|
this.viewer.scene.globe.enableLighting = enable;
|
this.viewer.shadows = enable;
|
}
|
|
// 开始日照模拟
|
startClockMock(speed) {
|
speed = speed || 1;
|
const viewer = this.viewer;
|
// 起始时间
|
var start = new Cesium.JulianDate();
|
// 结束时间
|
var stop = Cesium.JulianDate.addSeconds(
|
start,
|
86400,
|
new Cesium.JulianDate()
|
);
|
// 设置始时钟始时间
|
viewer.clock.startTime = start.clone();
|
// 设置时钟当前时间
|
viewer.clock.currentTime = start.clone();
|
// 设置始终停止时间
|
viewer.clock.stopTime = stop.clone();
|
viewer.clock.clockStep = Cesium.ClockStep.SYSTEM_CLOCK_MULTIPLIER;
|
viewer.clock.clockRange = Cesium.ClockRange.LOOP_STOP;
|
// 时间速率，数字越大时间过的越快
|
viewer.clock.multiplier = speed * 9000;
|
viewer.clock.shouldAnimate = true;
|
return this;
|
}
|
|
// 停止日照模拟
|
stopClockMock() {
|
const viewer = this.viewer;
|
// 起始时间
|
var start = new Cesium.JulianDate();
|
// 结束时间
|
var stop = Cesium.JulianDate.addDays(start, 1, new Cesium.JulianDate());
|
// 设置始时钟始时间
|
viewer.clock.startTime = start.clone();
|
// 设置时钟当前时间
|
viewer.clock.currentTime = start.clone();
|
// 设置始终停止时间
|
viewer.clock.stopTime = stop.clone();
|
viewer.clock.clockStep = Cesium.ClockStep.SYSTEM_CLOCK_MULTIPLIER;
|
viewer.clock.clockRange = Cesium.ClockRange.UNBOUNDED;
|
// 时间速率，数字越大时间过的越快
|
viewer.clock.multiplier = 1;
|
viewer.clock.shouldAnimate = false;
|
return this;
|
}
|
|
// 设置视点
|
setViewPoints(viewPoints) {
|
this.viewPoints = viewPoints || [];
|
}
|
|
addViewPoint({ title } = {}) {
|
this.viewPoints.push({
|
id: Cesium.createGuid(),
|
title: title,
|
viewPoint: this.getViewPoint(),
|
});
|
}
|
|
removeViewPoint(id) {
|
this.viewPoints = this.viewPoints.filter(v => v.id !== id);
|
}
|
|
focusViewPoint(id) {
|
const viewPoint = this.viewPoints.filter(v => v.id === id)[0];
|
if (!viewPoint) return;
|
this.flyToViewPoint(viewPoint.viewPoint);
|
}
|
|
destroy() {
|
this.measureTool.clearMeasure();
|
this.clearAllPlots();
|
this.removeModels();
|
// this.viewer.destroy();
|
// this.viewer = null;
|
// this.fire(UI_CHANGE_EVENT);
|
}
|
}
|
