1201 lines
41 KiB
JavaScript
1201 lines
41 KiB
JavaScript
import EventBinding from '../../Element/Dialog/eventBinding';
|
||
import Base from "../index";
|
||
import MouseEvent from '../../../Event/index'
|
||
import Controller from "../../../Controller/index";
|
||
import MouseTip from '../../../MouseTip'
|
||
import { setActiveViewer, closeRotateAround } from '../../../Global/global'
|
||
|
||
class TrajectoryMotionObject extends Base {
|
||
#lineEdit = false
|
||
/**
|
||
* @constructor
|
||
* @description 轨迹运动
|
||
* @param options {object}
|
||
* @param options.name {string} 名称
|
||
* @param options.speed=1 {number} 运行速度(米/每秒)
|
||
* @param options.delay=0 {number} 运动延迟时间(毫秒)
|
||
* @param options.loop=true {boolean} 循环
|
||
* @param options.height {number} 起始点高度
|
||
* @param options.ground=false {boolean} 贴地
|
||
* @param options.state=true {boolean} 模型运动
|
||
* @param options.routeDirection=true {boolean} 路径方向
|
||
* @param options.viewFollow=false {boolean} 视角跟随
|
||
* @param options.line {object} 路径参数
|
||
* @param options.line.show=true {boolean} 路径显隐
|
||
* @param options.line.smooth=false {boolean} 路径圆滑
|
||
* @param options.line.noseToTail=false {boolean} 路径收尾相联
|
||
* @param {Array.<object>} options.line.positions 经纬度和高度的列表，值交替 [{lon,lat,alt},...]
|
||
* @param _Dialog {object} 弹框事件
|
||
* @param _Dialog.confirmCallBack {function} 弹框确认时的回调
|
||
* */
|
||
constructor(sdk, options = {}, _Dialog = {}) {
|
||
super(sdk, options);
|
||
this.options.name = options.name || ''
|
||
this.options.show = (options.show || options.show === false) ? options.show : true
|
||
this.options.speed = (options.speed || options.speed === 0) ? options.speed : 1
|
||
this.options.totalTime = options.totalTime
|
||
if(options.totalTime || options.totalTime===0) {
|
||
this.totalTime = options.totalTime
|
||
}
|
||
this.options.delay = options.delay || 0
|
||
this.options.loop = options.loop || options.loop === false ? options.loop : true
|
||
this.options.line = options.line = options.line || {}
|
||
this.options.line.positions = options.line.positions || []
|
||
this.options.height = (options.height || options.height === 0) ? options.height : (this.options.line.positions[0] ? this.options.line.positions[0].alt : 0)
|
||
this.options.line.show = options.line.show || options.line.show === false ? options.line.show : true
|
||
this.options.line.smooth = options.line.smooth ? options.line.smooth : false
|
||
this.options.line.noseToTail = options.line.noseToTail ? options.line.noseToTail : false
|
||
this.positions_smooth = []
|
||
this.options.ground = options.ground || false
|
||
this.options.state = (options.state || options.state === false) ? options.state : true
|
||
this.options.routeDirection = (options.routeDirection || options.routeDirection === false) ? options.routeDirection : true
|
||
this.keyPoints = []
|
||
this.realTimePositions = []
|
||
this._elms = {};
|
||
this.Dialog = _Dialog
|
||
this.realTimeRouteArray = []
|
||
// this._initial = {}
|
||
this._current = {
|
||
heading: 0,
|
||
pitch: 0,
|
||
roll: 0
|
||
}
|
||
// this.options.firstPerson = false
|
||
this.distance
|
||
// this.addModel()
|
||
|
||
if (this.options.line.positions.length < 2) {
|
||
this._error = '最少需要两个坐标！'
|
||
console.warn(this._error)
|
||
window.ELEMENT && window.ELEMENT.Message({
|
||
message: this._error,
|
||
type: 'warning',
|
||
duration: 1500
|
||
});
|
||
}
|
||
else {
|
||
this.ControllerObject = new Controller(this.sdk)
|
||
this._EventBinding = new EventBinding()
|
||
TrajectoryMotionObject.addLine(this)
|
||
this.firstPersonView = false
|
||
this.options.viewFollow = false
|
||
}
|
||
|
||
// animateUpdate()
|
||
// function animateUpdate() {
|
||
// requestAnimationFrame(animateUpdate);
|
||
// TWEEN.update();
|
||
// }
|
||
}
|
||
|
||
get type() {
|
||
return 'TrajectoryMotionObject'
|
||
}
|
||
|
||
get show() {
|
||
return this.options.show
|
||
}
|
||
|
||
set show(v) {
|
||
if (typeof v === "boolean") {
|
||
this.options.show = v
|
||
if (v) {
|
||
this.line.show = this.lineShow
|
||
for (let i = 0; i < this.keyPoints.length; i++) {
|
||
this.keyPoints[i].show = this.keyPointShow
|
||
}
|
||
}
|
||
else {
|
||
this.line.show = v
|
||
for (let i = 0; i < this.keyPoints.length; i++) {
|
||
this.keyPoints[i].show = v
|
||
}
|
||
}
|
||
if (this._DialogObject && this._DialogObject.showBtn) {
|
||
this._DialogObject.showBtn.checked = v
|
||
}
|
||
} else {
|
||
console.error("参数必须为boolean")
|
||
}
|
||
}
|
||
|
||
get height() {
|
||
return this.options.height
|
||
}
|
||
set height(v) {
|
||
this.options.height = v
|
||
if (this.line) {
|
||
if (this.ground) {
|
||
this.line.polyline.clampToGround = true
|
||
for (let i = 0; i < this.keyPoints.length; i++) {
|
||
this.sdk.viewer.scene.clampToHeightMostDetailed([new Cesium.Cartesian3.fromDegrees(this.options.line.positions[i].lng, this.options.line.positions[i].lat)]).then((result) => {
|
||
this.keyPoints[i].position = result[0]
|
||
})
|
||
}
|
||
}
|
||
else {
|
||
let dvalue = this.options.height - this.options.line.positions[0].alt
|
||
this.line.polyline.clampToGround = false
|
||
for (let i = 0; i < this.keyPoints.length; i++) {
|
||
this.options.line.positions[i].alt += dvalue
|
||
this.keyPoints[i].position = Cesium.Cartesian3.fromDegrees(this.options.line.positions[i].lng, this.options.line.positions[i].lat, this.options.line.positions[i].alt)
|
||
}
|
||
}
|
||
}
|
||
let positions_smooth = this._renewLine(this.options.line.positions)
|
||
this.line.polyline.positions = positions_smooth
|
||
this._elms.height && this._elms.height.forEach((item) => {
|
||
item.value = v
|
||
})
|
||
}
|
||
|
||
get ground() {
|
||
return this.options.ground
|
||
}
|
||
set ground(v) {
|
||
this.lineEdit = false
|
||
this.options.ground = v
|
||
this.realTimeLine.polyline.clampToGround = v
|
||
this.height = this.options.height
|
||
this._elms.ground && this._elms.ground.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
get speed() {
|
||
return this.options.speed
|
||
}
|
||
set speed(v) {
|
||
if (v <= 0) {
|
||
v = 0.01
|
||
}
|
||
this.options.speed = v
|
||
if (this.distance || this.distance === 0) {
|
||
this.options.totalTime = (this.distance*1000) / this.options.speed
|
||
// this.TweenAnimate._object.distance/this.TweenAnimate._valuesEnd.distance
|
||
if(this.TweenAnimate && this.state) {
|
||
this.TweenAnimate && (this.setMovePositionByDistance(this.TweenAnimate._object.distance))
|
||
}
|
||
this._elms.speed && this._elms.speed.forEach((item) => {
|
||
item.value = v
|
||
})
|
||
this._elms.totalTime && this._elms.totalTime.forEach((item) => {
|
||
item.value = this.options.totalTime
|
||
})
|
||
}
|
||
|
||
}
|
||
|
||
get totalTime() {
|
||
return this.options.totalTime
|
||
}
|
||
set totalTime(v) {
|
||
this.options.totalTime = v
|
||
if (this.distance || this.distance === 0) {
|
||
this.options.speed = (this.distance*1000) / this.options.totalTime
|
||
this.TweenAnimate && (this.setMovePositionByDistance(this.TweenAnimate._object.distance))
|
||
this._elms.totalTime && this._elms.totalTime.forEach((item) => {
|
||
item.value = v
|
||
})
|
||
this._elms.speed && this._elms.speed.forEach((item) => {
|
||
item.value = this.options.speed
|
||
})
|
||
}
|
||
|
||
}
|
||
|
||
get smooth() {
|
||
return this.options.line.smooth
|
||
}
|
||
set smooth(v) {
|
||
this.lineEdit = false
|
||
this.options.line.smooth = v
|
||
let positions = this._renewLine(this.options.line.positions)
|
||
this.line.polyline.positions = positions
|
||
this.modelMove(positions)
|
||
this._elms.smooth && this._elms.smooth.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
get delay() {
|
||
return this.options.delay
|
||
}
|
||
set delay(v) {
|
||
this.options.delay = v
|
||
if (this.TweenAnimate) {
|
||
this.TweenAnimate.delay(this.delay)
|
||
}
|
||
this._elms.delay && this._elms.delay.forEach((item) => {
|
||
item.value = v
|
||
})
|
||
}
|
||
|
||
get state() {
|
||
return this.options.state
|
||
}
|
||
set state(v) {
|
||
this.options.state = v
|
||
|
||
if (this.editObj) {
|
||
this.editObj.destroy()
|
||
this.editObj = null
|
||
}
|
||
if (this.TweenAnimate) {
|
||
if (v) {
|
||
this.speed = this.speed
|
||
}
|
||
else {
|
||
this.TweenAnimate.pause()
|
||
}
|
||
}
|
||
else {
|
||
if (v) {
|
||
let positions = this._renewLine(this.options.line.positions)
|
||
this.modelMove(positions)
|
||
}
|
||
}
|
||
this._elms.state && this._elms.state.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
get noseToTail() {
|
||
return this.options.line.noseToTail
|
||
}
|
||
set noseToTail(v) {
|
||
this.lineEdit = false
|
||
this.options.line.noseToTail = v
|
||
let fromDegreesArrayHeights = []
|
||
for (let i = 0; i < this.options.line.positions.length; i++) {
|
||
fromDegreesArrayHeights.push(this.options.line.positions[i].lng, this.options.line.positions[i].lat, this.options.line.positions[i].alt)
|
||
}
|
||
let nosmooth = Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArrayHeights)
|
||
if (this.line) {
|
||
let positions_smooth = this._renewLine(this.options.line.positions)
|
||
this.line.polyline.positions = positions_smooth
|
||
this.modelMove(positions_smooth)
|
||
}
|
||
this._elms.noseToTail && this._elms.noseToTail.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
get lineShow() {
|
||
return this.options.line.show
|
||
}
|
||
set lineShow(v) {
|
||
if (v) {
|
||
this.realTimeRoute = false
|
||
}
|
||
this.options.line.show = v
|
||
if (this.line && this.show) {
|
||
this.line.show = v
|
||
}
|
||
this._elms.lineShow && this._elms.lineShow.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
get realTimeRoute() {
|
||
return this.options.realTimeRoute
|
||
}
|
||
set realTimeRoute(v) {
|
||
if (v) {
|
||
this.lineShow = false
|
||
this.keyPointShow = false
|
||
}
|
||
this.options.realTimeRoute = v
|
||
if (this.realTimeLine && this.show) {
|
||
this.realTimeLine.show = v
|
||
}
|
||
this._elms.realTimeRoute && this._elms.realTimeRoute.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
get keyPointShow() {
|
||
return this.options.line.keyPoint
|
||
}
|
||
set keyPointShow(v) {
|
||
this.options.line.keyPoint = v
|
||
for (let i = 0; i < this.keyPoints.length; i++) {
|
||
if (this.show) {
|
||
this.keyPoints[i].show = v
|
||
}
|
||
}
|
||
this._elms.keyPointShow && this._elms.keyPointShow.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
if (!v && this.lineEdit) {
|
||
// 关闭线编辑
|
||
this.#lineEdit = v
|
||
YJ.Measure.SetMeasureStatus(false)
|
||
this.event && this.event.destroy()
|
||
this.ControllerObject && this.ControllerObject.destroy()
|
||
this.tip && this.tip.destroy()
|
||
this.tip = null
|
||
this._elms.lineEdit && this._elms.lineEdit.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
}
|
||
|
||
get lineEdit() {
|
||
return this.#lineEdit
|
||
}
|
||
|
||
set lineEdit(v) {
|
||
let linePositions = []
|
||
let computePositionsSmooth = (positions) => {
|
||
linePositions = this._renewLine(positions)
|
||
this.modelMove(linePositions)
|
||
}
|
||
if (v) {
|
||
this.viewFollow = false
|
||
if (YJ.Measure.GetMeasureStatus()) {
|
||
console.warn('上一次测量未结束')
|
||
this.lineEdit = false
|
||
return
|
||
}
|
||
else {
|
||
this.ground = false
|
||
this.smooth = false
|
||
this.state = false
|
||
YJ.Measure.SetMeasureStatus(true)
|
||
this.tip = new MouseTip('请选择一个顶点，右键取消', this.sdk)
|
||
this.event = new MouseEvent(this.sdk)
|
||
let selectPoint
|
||
computePositionsSmooth([...this.options.line.positions])
|
||
this.event.mouse_left((movement, cartesian) => {
|
||
let pick = this.sdk.viewer.scene.pick(movement.position);
|
||
if (pick && pick.id && pick.id.name && pick.id.name === 'node-secondary-edit-point') {
|
||
for (let i = 0; i < this.keyPoints.length; i++) {
|
||
if (this.keyPoints[i].id === pick.id.id) {
|
||
// this.keyPoints[i].show = false
|
||
selectPoint = pick.id
|
||
this.ControllerObject.position = this.options.line.positions[selectPoint.index]
|
||
this.ControllerObject.editTranslational()
|
||
this.tip && this.tip.destroy()
|
||
this.tip = null
|
||
this.ControllerObject.controllerCallBack = (params) => {
|
||
// console.log('params', params)
|
||
this.options.line.positions[selectPoint.index] = params.position
|
||
selectPoint.position = Cesium.Cartesian3.fromDegrees(params.position.lng, params.position.lat, params.position.alt)
|
||
computePositionsSmooth([...this.options.line.positions])
|
||
}
|
||
break
|
||
}
|
||
}
|
||
// originalPosition = this.cartesian3Towgs84(cartesian, this.sdk.viewer)
|
||
}
|
||
})
|
||
this.event.mouse_right((movement, cartesian) => {
|
||
// if (selectPoint) {
|
||
// let positions = [...this.options.line.positions]
|
||
// selectPoint.position = Cesium.Cartesian3.fromDegrees(positions[selectPoint.index].lng, positions[selectPoint.index].lat, positions[selectPoint.index].alt)
|
||
// computePositionsSmooth(positions)
|
||
// }
|
||
this.keyPointShow = false
|
||
YJ.Measure.SetMeasureStatus(false)
|
||
this.event.destroy()
|
||
this.tip && this.tip.destroy()
|
||
this.tip = null
|
||
this.ControllerObject.destroy()
|
||
})
|
||
this.event.mouse_move((movement, cartesian) => {
|
||
// if (selectPoint) {
|
||
// let positions = [...this.options.line.positions]
|
||
// positions[selectPoint.index] = this.cartesian3Towgs84(cartesian, this.sdk.viewer)
|
||
// selectPoint.position = cartesian
|
||
// computePositionsSmooth(positions)
|
||
// // that.options.positions[selectPoint.index] = that.cartesian3Towgs84(cartesian, that.sdk.viewer)
|
||
// // let positions = that.options.positions
|
||
// // let fromDegreesArray = []
|
||
// // for (let i = 0; i < positions.length; i++) {
|
||
// // fromDegreesArray.push(positions[i].lng, positions[i].lat, positions[i].alt)
|
||
// // }
|
||
// // newpositions = Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArray)
|
||
// // if (that.options.positions.length === 1) {
|
||
// // that.label.position = [that.options.positions[0].lng, that.options.positions[0].lat, that.options.height]
|
||
// // }
|
||
// }
|
||
this.tip && this.tip.setPosition(
|
||
cartesian,
|
||
movement.endPosition.x,
|
||
movement.endPosition.y
|
||
)
|
||
})
|
||
this.line.polyline.positions = new Cesium.CallbackProperty(function () {
|
||
return linePositions
|
||
}, false)
|
||
}
|
||
// 显示关键点
|
||
this.keyPointShow = v
|
||
}
|
||
else {
|
||
if (this.lineEdit) {
|
||
YJ.Measure.SetMeasureStatus(false)
|
||
this.event.destroy()
|
||
this.tip && this.tip.destroy()
|
||
this.tip = null
|
||
}
|
||
// 隐藏关键点
|
||
this.keyPointShow = v
|
||
this.ControllerObject.destroy()
|
||
}
|
||
this.#lineEdit = v
|
||
this._elms.lineEdit && this._elms.lineEdit.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
get routeDirection() {
|
||
return this.options.routeDirection
|
||
}
|
||
set routeDirection(v) {
|
||
this.options.routeDirection = v
|
||
this._elms.routeDirection && this._elms.routeDirection.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
get loop() {
|
||
return this.options.loop
|
||
}
|
||
set loop(v) {
|
||
this.options.loop = v
|
||
if (v) {
|
||
this.TweenAnimate.repeat(Infinity)
|
||
}
|
||
else {
|
||
this.TweenAnimate.repeat()
|
||
}
|
||
this._elms.loop && this._elms.loop.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
get firstPersonView() {
|
||
return this.options.firstPersonView
|
||
}
|
||
|
||
set firstPersonView(v) {
|
||
// this.state = true
|
||
this.sdk.viewer._firstPersonView = v
|
||
this.options.firstPersonView = v
|
||
if (this.options.firstPersonView) {
|
||
if (this._DialogObject && this._DialogObject._element.content) {
|
||
let e_firstPerson = this._DialogObject._element.content.querySelectorAll("button[name='firstPerson']")
|
||
e_firstPerson[0].className = 'btn is-active'
|
||
e_firstPerson[1].className = 'btn'
|
||
}
|
||
if (this.sdk.viewer.trackedEntity) {
|
||
this.sdk.viewer.entities.remove(this.sdk.viewer.trackedEntity)
|
||
this.sdk.viewer.trackedEntity = null
|
||
}
|
||
}
|
||
else {
|
||
if (this._DialogObject && this._DialogObject._element.content) {
|
||
let e_firstPerson = this._DialogObject._element.content.querySelectorAll("button[name='firstPerson']")
|
||
if (e_firstPerson[0] && e_firstPerson[1]) {
|
||
e_firstPerson[0].className = 'btn'
|
||
e_firstPerson[1].className = 'btn is-active'
|
||
}
|
||
}
|
||
if (this.viewFollow) {
|
||
if (this.sdk.viewer.trackedEntity) {
|
||
this.sdk.viewer.entities.remove(this.sdk.viewer.trackedEntity)
|
||
}
|
||
let pointEntity = this.sdk.viewer.entities.add({
|
||
// show: false,
|
||
position: this.positions_smooth[0], // position of the point
|
||
point: {
|
||
color: Cesium.Color.RED.withAlpha(0), // color of the point
|
||
pixelSize: 0
|
||
}
|
||
});
|
||
this.sdk.viewer.trackedEntity = pointEntity;
|
||
}
|
||
}
|
||
}
|
||
|
||
get viewFollow() {
|
||
return this.options.viewFollow
|
||
}
|
||
set viewFollow(v) {
|
||
this.options.viewFollow = v
|
||
if (!this.options.viewFollow) {
|
||
this.firstPersonView = false
|
||
}
|
||
else {
|
||
this.lineEdit = false
|
||
}
|
||
if (this.options.firstPersonView) {
|
||
if (this.sdk.viewer.trackedEntity) {
|
||
this.sdk.viewer.entities.remove(this.sdk.viewer.trackedEntity)
|
||
this.sdk.viewer.trackedEntity = null
|
||
}
|
||
if (this._DialogObject && this._DialogObject._element.content) {
|
||
let e_firstPerson = this._DialogObject._element.content.querySelectorAll("button[name='firstPerson']")
|
||
if (e_firstPerson[0] && e_firstPerson[1]) {
|
||
e_firstPerson[0].className = 'btn'
|
||
e_firstPerson[1].className = 'btn is-active'
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
if (this.sdk.viewer.trackedEntity) {
|
||
this.sdk.viewer.entities.remove(this.sdk.viewer.trackedEntity)
|
||
this.sdk.viewer.trackedEntity = null
|
||
}
|
||
if (v) {
|
||
let pointEntity = this.sdk.viewer.entities.add({
|
||
// show: false,
|
||
position: this.current.position, // position of the point
|
||
point: {
|
||
color: Cesium.Color.RED.withAlpha(0), // color of the point
|
||
pixelSize: 0
|
||
}
|
||
});
|
||
this.sdk.viewer.trackedEntity = pointEntity;
|
||
}
|
||
}
|
||
this._elms.viewFollow && this._elms.viewFollow.forEach((item) => {
|
||
item.checked = v
|
||
})
|
||
}
|
||
|
||
moveCallBack(that) {
|
||
// if((that.lng || that.lng == 0) && (that.lat || that.lat == 0) && (that.alt || that.lat == 0)) {
|
||
// this._initial.position = {
|
||
// lng: that.lng,
|
||
// lat: that.lat,
|
||
// alt: that.alt,
|
||
// }
|
||
// }
|
||
// if(that.rotateX || that.rotateX == 0 ) {
|
||
// this._initial.pitch = that.rotateX
|
||
// }
|
||
// if(that.rotateY || that.rotateY == 0) {
|
||
// this._initial.roll = that.rotateY
|
||
// }
|
||
// if(that.rotateZ || that.rotateZ == 0) {
|
||
// this._initial.heading = that.rotateZ
|
||
// }
|
||
this.setPosition = that.setPosition.bind(that)
|
||
}
|
||
|
||
// get moveCallBack() {
|
||
// return this.options.moveCallBack
|
||
// }
|
||
|
||
// set moveCallBack(v) {
|
||
// this.options.moveCallBack = v
|
||
// }
|
||
|
||
get current() {
|
||
return this._current
|
||
}
|
||
|
||
set current(v) {
|
||
this._current = v
|
||
let pos = this.cartesian3Towgs84(this._current.position, this.sdk.viewer)
|
||
this.setPosition && this.setPosition({ ...this._current, position: { ...pos } })
|
||
}
|
||
|
||
// 创建路径
|
||
static addLine(that) {
|
||
let positions_smooth = that._renewLine(that.options.line.positions)
|
||
that.current.position = positions_smooth[0]
|
||
that.line = that.sdk.viewer.entities.add({
|
||
id: that.options.id + '-2',
|
||
show: that.options.show ? that.options.line.show : false,
|
||
polyline: {
|
||
positions: positions_smooth,
|
||
width: 2,
|
||
clampToGround: that.ground,
|
||
material: Cesium.Color.fromCssColorString('#ffffff'),
|
||
zIndex: that.sdk._entityZIndex
|
||
},
|
||
})
|
||
that.realTimeLine = that.sdk.viewer.entities.add({
|
||
id: that.options.id + '-3',
|
||
show: that.options.realTimeRoute ? that.options.realTimeRoute : false,
|
||
polyline: {
|
||
positions: new Cesium.CallbackProperty(function () {
|
||
return that.realTimePositions
|
||
}, false),
|
||
width: 2,
|
||
clampToGround: that.ground,
|
||
zIndex: that.sdk._entityZIndex,
|
||
material: Cesium.Color.fromCssColorString('#ff0000')
|
||
},
|
||
})
|
||
that.sdk._entityZIndex++
|
||
let event = new MouseEvent(that.sdk)
|
||
event.mouse_right((movement, cartesian) => {
|
||
that.viewFollow = false
|
||
})
|
||
TrajectoryMotionObject.addKeyPoint(that)
|
||
that.noseToTail = that.options.line.noseToTail
|
||
that.smooth = that.options.line.smooth
|
||
}
|
||
// 创建模型
|
||
static addModel(that) {
|
||
// that.model = that.sdk.viewer.scene.primitives.add(
|
||
// Cesium.Model.fromGltf({
|
||
// id: that.options.id,
|
||
// url: that.options.model.url,
|
||
// show: that.options.show ? that.options.model.show : false,
|
||
// scale: that.options.model.scale,
|
||
// // minimumPixelSize: that.options.model.pixelSize,
|
||
// // maximumScale: 100000,
|
||
// // allowPicking: false
|
||
// })
|
||
// );
|
||
|
||
// let cartographic = Cesium.Cartographic.fromDegrees(103, 65, 100);
|
||
// let position = that.sdk.viewer.scene.globe.ellipsoid.cartographicToCartesian(cartographic);
|
||
// // 设置模型的旋转角度，使其水平放置于地面
|
||
// let matrix = Cesium.Transforms.eastNorthUpToFixedFrame(that.positions_smooth[0])
|
||
// that.model.modelMatrix = matrix
|
||
// that.model.position = that.positions_smooth[0]
|
||
// // 模型大小比例
|
||
// // Cesium.Matrix4.multiplyByScale(matrix, new Cesium.Cartesian3(0.1, 0.1, 0.1), this.entity.modelMatrix)
|
||
|
||
// let positions = that.options.line.positions
|
||
// let fromDegreesArrayHeights = []
|
||
// for (let i = 0; i < positions.length; i++) {
|
||
// fromDegreesArrayHeights.push(positions[i].lng, positions[i].lat, positions[i].alt)
|
||
// }
|
||
// let pos = that.smooth ? that.positions_smooth : Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArrayHeights)
|
||
// that.modelMove(pos)
|
||
|
||
// that.model.readyPromise.then(() => {
|
||
// that.modelAnimate = that.options.model.animate
|
||
// })
|
||
// that.entity = that.model
|
||
}
|
||
|
||
// 创建关键点
|
||
static async addKeyPoint(that) {
|
||
for (let i = 0; i < that.options.line.positions.length; i++) {
|
||
let height = await that.getClampToHeight(that.options.line.positions[i])
|
||
let result = await Cesium.Cartesian3.fromDegrees(that.options.line.positions[i].lng, that.options.line.positions[i].lat, height)
|
||
let entity = that.sdk.viewer.entities.add({
|
||
name: 'node-secondary-edit-point',
|
||
index: i,
|
||
show: that.options.line.keyPoint || false,
|
||
position: that.ground ? result : Cesium.Cartesian3.fromDegrees(that.options.line.positions[i].lng, that.options.line.positions[i].lat, that.options.line.positions[i].alt),
|
||
billboard: {
|
||
image: that.getSourceRootPath() + '/img/point.png',
|
||
width: 15,
|
||
height: 15,
|
||
disableDepthTestDistance: Number.POSITIVE_INFINITY,
|
||
color: Cesium.Color.WHITE.withAlpha(0.99)
|
||
},
|
||
})
|
||
that.keyPoints.push(entity)
|
||
}
|
||
}
|
||
|
||
// 模型移动
|
||
async modelMove(positions, option = { time: 0 }) {
|
||
let _this = this
|
||
let time = option.time || 0
|
||
let startDistance = option.distance || 0
|
||
let viewer = this.sdk.viewer
|
||
this.removeModelAnimate()
|
||
|
||
let lineString = []
|
||
for (let i = 0; i < positions.length; i++) {
|
||
let position = this.cartesian3Towgs84(positions[i], viewer)
|
||
lineString.push([position.lng, position.lat, position.alt])
|
||
}
|
||
// console.log(lineString)
|
||
let line = turf.lineString(lineString);
|
||
this.distance = turf.length(line, { units: 'kilometers' });
|
||
if(!this.totalTime) {
|
||
this.totalTime = (this.distance*1000) / this.options.speed // 总耗时（秒）
|
||
}
|
||
let totalTime = this.totalTime
|
||
|
||
if (time) {
|
||
if (time > totalTime) {
|
||
time = totalTime
|
||
}
|
||
startDistance = (time / totalTime) * this.distance
|
||
}
|
||
else {
|
||
// this._initial.position && (this._current.position = this.positions_smooth[0])
|
||
// if(this._initial.pitch || this._initial.pitch === 0) {
|
||
// this._current.pitch = this._initial.pitch
|
||
// }
|
||
// if(this._initial.roll || this._initial.roll === 0) {
|
||
// this._current.roll = this._initial.roll
|
||
// }
|
||
// if(this._initial.heading || this._initial.heading === 0) {
|
||
// this._current.heading = this._initial.heading
|
||
// }
|
||
}
|
||
let lastDistance = 0
|
||
let motionArray = []
|
||
let HeadingPitchRoll
|
||
let HeadingPitchRoll2
|
||
let previous = {}
|
||
let m = 0
|
||
|
||
let modelArray = []
|
||
for (let [key, value] of this.sdk.entityMap) {
|
||
if (value.type && value.type === 'glb') {
|
||
modelArray.push(value.entity)
|
||
}
|
||
}
|
||
let first = true
|
||
this.TweenAnimate = new TWEEN.Tween({ distance: startDistance }).to({ distance: this.distance }, (totalTime - time)*1000).
|
||
delay(this.delay).easing(TWEEN.Easing.Linear.None).repeat(this.options.loop ? Infinity : 0).onRepeat(() => {
|
||
if (time) {
|
||
this.modelMove(positions)
|
||
}
|
||
}).onUpdate(async (r, a) => {
|
||
|
||
if (this.TweenAnimate._duration == Infinity) {
|
||
return
|
||
}
|
||
m++
|
||
if (!this.sdk.viewer) {
|
||
this.removeModelAnimate()
|
||
return
|
||
}
|
||
|
||
setPosition(r.distance)
|
||
}).onEveryStart(() => {
|
||
this.realTimeRouteArray = []
|
||
}).onComplete((d) => {
|
||
this.state = false
|
||
this.removeModelAnimate()
|
||
// let runtimeAnimation = this.model._activeAnimations._runtimeAnimations
|
||
// // let animations = await this.model.readyPromise
|
||
// for (let i = runtimeAnimation.length - 1; i >= 0; i--) {
|
||
// switch (runtimeAnimation[i].name) {
|
||
// case '跑':
|
||
// this.model.activeAnimations.remove(runtimeAnimation[i])
|
||
// break;
|
||
// default:
|
||
// }
|
||
// }
|
||
});
|
||
if (this.state) {
|
||
this.TweenAnimate.start()
|
||
}
|
||
else {
|
||
setPosition(startDistance)
|
||
}
|
||
|
||
async function setPosition(distance) {
|
||
let start = 0;
|
||
let stop = distance;
|
||
let coordinates
|
||
let sliced = line
|
||
if (stop) {
|
||
let sliced = await turf.lineSliceAlong(line, start, stop, { units: 'kilometers' });
|
||
// _this.realTimeRouteArray = sliced+
|
||
coordinates = [...sliced.geometry.coordinates[sliced.geometry.coordinates.length - 1]]
|
||
}
|
||
else {
|
||
coordinates = [...line.geometry.coordinates[0]]
|
||
}
|
||
let position
|
||
let positionCamera
|
||
|
||
if (_this.ground) {
|
||
// if (viewer.terrainProvider.availability) {
|
||
// let result = await new Cesium.sampleTerrainMostDetailed(viewer.terrainProvider, [Cesium.Cartographic.fromDegrees(coordinates[0], coordinates[1])]);
|
||
// position = Cesium.Cartesian3.fromDegrees(coordinates[0], coordinates[1], result[0].height)
|
||
// positionCamera = Cesium.Cartesian3.fromDegrees(coordinates[0], coordinates[1], result[0].height + 1)
|
||
// }
|
||
// else {
|
||
// position = Cesium.Cartesian3.fromDegrees(coordinates[0], coordinates[1])
|
||
// positionCamera = Cesium.Cartesian3.fromDegrees(coordinates[0], coordinates[1], 1)
|
||
// }
|
||
let result = await _this.sdk.viewer.scene.clampToHeight(new Cesium.Cartesian3.fromDegrees(coordinates[0], coordinates[1]), modelArray)
|
||
position = result
|
||
if (!position) {
|
||
position = new Cesium.Cartesian3.fromDegrees(coordinates[0], coordinates[1])
|
||
}
|
||
let pos3 = _this.cartesian3Towgs84(position, viewer);
|
||
let height2 = 0
|
||
try {
|
||
let position2 = await Cesium.sampleTerrainMostDetailed(
|
||
_this.sdk.viewer.scene.terrainProvider,
|
||
[Cesium.Cartographic.fromDegrees(pos3.lng, pos3.lat)]
|
||
)
|
||
height2 = position2[0].height
|
||
} catch (error) {
|
||
height2 = 0
|
||
}
|
||
if (pos3.alt < height2) {
|
||
pos3.alt = height2
|
||
}
|
||
pos3.alt = Number(pos3.alt.toFixed(1))
|
||
position = Cesium.Cartesian3.fromDegrees(pos3.lng, pos3.lat, pos3.alt)
|
||
positionCamera = Cesium.Cartesian3.fromDegrees(coordinates[0], coordinates[1], _this.cartesian3Towgs84(position, _this.sdk.viewer).alt + 1)
|
||
let fromDegreesArray = []
|
||
for (let i = 0; i < sliced.geometry.coordinates.length; i++) {
|
||
fromDegreesArray.push(sliced.geometry.coordinates[i][0], sliced.geometry.coordinates[i][1])
|
||
}
|
||
_this.realTimePositions = Cesium.Cartesian3.fromDegreesArray(fromDegreesArray)
|
||
// _this.realTimeLine.polyline.positions =
|
||
}
|
||
else {
|
||
let cartesian3 = _this.spline.evaluate(distance / _this.distance)
|
||
coordinates = _this.cartesian3Towgs84(cartesian3, viewer);
|
||
position = Cesium.Cartesian3.fromDegrees(coordinates.lng, coordinates.lat, coordinates.alt)
|
||
positionCamera = Cesium.Cartesian3.fromDegrees(coordinates.lng, coordinates.lat, coordinates.alt + 1)
|
||
let positions_smooth = []
|
||
for (let i = 0; i <= 100; i++) {
|
||
if ((i / 100) > (distance / _this.distance)) {
|
||
break
|
||
}
|
||
let cartesian3 = _this.spline.evaluate(i / 100);
|
||
positions_smooth.push(cartesian3);
|
||
}
|
||
positions_smooth.push(cartesian3)
|
||
_this.realTimePositions = positions_smooth
|
||
}
|
||
|
||
HeadingPitchRoll = getHeadingPitchRoll(_this.current.position, position)
|
||
if (previous && previous.position) {
|
||
HeadingPitchRoll2 = getHeadingPitchRoll(previous.position, position)
|
||
HeadingPitchRoll.pitch = HeadingPitchRoll2.pitch
|
||
}
|
||
previous.position = _this.current.position
|
||
let modeHeadingPitchRoll = Cesium.HeadingPitchRoll.fromDegrees(_this.current.heading, _this.current.pitch, _this.current.roll)
|
||
let heading = 0
|
||
let pitch = 0
|
||
let roll = 0
|
||
if (_this.options.routeDirection) {
|
||
heading = (HeadingPitchRoll.heading - modeHeadingPitchRoll.heading) * (180 / Math.PI) - 90 + _this.current.heading
|
||
pitch = HeadingPitchRoll.pitch * (180 / Math.PI)
|
||
}
|
||
else {
|
||
heading = _this.current.heading
|
||
pitch = _this.current.pitch
|
||
}
|
||
|
||
roll = _this.current.roll
|
||
// console.log((HeadingPitchRoll.heading - modeHeadingPitchRoll.heading) * (180 / Math.PI))
|
||
if (isNaN(heading) || isNaN(pitch) || isNaN(roll)) {
|
||
return
|
||
}
|
||
if (heading < 0 || heading > 180) {
|
||
pitch = -pitch
|
||
}
|
||
_this.current = {
|
||
position: position,
|
||
heading: heading,
|
||
pitch: pitch,
|
||
roll: roll
|
||
}
|
||
if (first) {
|
||
first = false
|
||
_this._first = {
|
||
position: position,
|
||
heading: heading,
|
||
pitch: pitch,
|
||
roll: roll
|
||
}
|
||
}
|
||
lastDistance = distance
|
||
// console.log(position)
|
||
_this.realTimeRouteArray.push(position)
|
||
if (_this.viewFollow) {
|
||
// console.log(heading)
|
||
if (_this.options.firstPersonView) {
|
||
_this.sdk.viewer.camera.setView({
|
||
destination: positionCamera,
|
||
orientation: {
|
||
heading: _this.sdk.viewer.camera.heading,
|
||
pitch: _this.sdk.viewer.camera.pitch,
|
||
roll: _this.sdk.viewer.camera.roll
|
||
}
|
||
})
|
||
}
|
||
else {
|
||
if (_this.sdk.viewer.trackedEntity) {
|
||
_this.sdk.viewer.trackedEntity.position = position
|
||
// _this.sdk.viewer.camera.position = position
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// function executeAnimate() {
|
||
// }
|
||
// setTimeout(() => {
|
||
// let i = 0
|
||
// function animate() {
|
||
// if (i < motionArray.length) {
|
||
// let result = motionArray[i].result;
|
||
// console.log(result)
|
||
// result.then((res) => {
|
||
// let position = Cesium.Cartesian3.fromDegrees(motionArray[i].lng, motionArray[i].lat, res[0].height)
|
||
|
||
// let HeadingPitchRoll = getHeadingPitchRoll(_this.model.position, position)
|
||
// let modeHeadingPitchRoll = Cesium.HeadingPitchRoll.fromDegrees(_this.options.model.heading, _this.options.model.pitch, _this.options.model.roll)
|
||
// let heading = 0
|
||
// let pitch = 0
|
||
// let roll = 0
|
||
// if (_this.options.routeDirection) {
|
||
// heading = (HeadingPitchRoll.heading - modeHeadingPitchRoll.heading) * (180 / Math.PI) - 90
|
||
// pitch = (HeadingPitchRoll.pitch - modeHeadingPitchRoll.pitch) * (180 / Math.PI)
|
||
// }
|
||
// else {
|
||
// heading = - _this.options.model.heading
|
||
// pitch = - _this.options.model.pitch
|
||
// }
|
||
// roll = - _this.options.model.roll
|
||
// // console.log(heading)
|
||
// let matrix = Cesium.Transforms.eastNorthUpToFixedFrame(position)
|
||
// _this.model.modelMatrix = Cesium.Matrix4.multiplyByMatrix3(matrix, Cesium.Matrix3.fromHeadingPitchRoll(Cesium.HeadingPitchRoll.fromDegrees(heading, pitch, roll)), _this.model.modelMatrix)
|
||
// _this.model.position = position
|
||
// if (_this.sdk.viewer.trackedEntity) {
|
||
// _this.sdk.viewer.trackedEntity.position = position
|
||
// }
|
||
// i++
|
||
// requestAnimationFrame(animate);
|
||
// })
|
||
|
||
// }
|
||
|
||
// }
|
||
// animate();
|
||
// }, 2000);
|
||
|
||
// 根据两个坐标点,获取Heading(朝向)
|
||
function getHeadingPitchRoll(pointA, pointB) {
|
||
// console.log(distance, _this.cartesian3Towgs84(pointA, viewer), _this.cartesian3Towgs84(pointB, viewer))
|
||
//建立以点A为原点，X轴为east,Y轴为north,Z轴朝上的坐标系
|
||
const transform = Cesium.Transforms.eastNorthUpToFixedFrame(pointA);
|
||
//向量AB
|
||
if (!pointB) {
|
||
return
|
||
}
|
||
const positionvector = Cesium.Cartesian3.subtract(pointB, pointA, new Cesium.Cartesian3());
|
||
//因transform是将A为原点的eastNorthUp坐标系中的点转换到世界坐标系的矩阵
|
||
//AB为世界坐标中的向量
|
||
//因此将AB向量转换为A原点坐标系中的向量，需乘以transform的逆矩阵。
|
||
const vector = Cesium.Matrix4.multiplyByPointAsVector(
|
||
Cesium.Matrix4.inverse(transform, new Cesium.Matrix4()),
|
||
positionvector,
|
||
new Cesium.Cartesian3()
|
||
);
|
||
//归一化
|
||
const direction = Cesium.Cartesian3.normalize(vector, new Cesium.Cartesian3());
|
||
//heading
|
||
const heading = Math.atan2(direction.y, direction.x) - Cesium.Math.PI_OVER_TWO;
|
||
let pitch = Cesium.Math.PI_OVER_TWO - Cesium.Math.acosClamped(direction.z);
|
||
let a = pitch * (180 / Math.PI)
|
||
if (a < 0) {
|
||
// a = (-a)
|
||
}
|
||
pitch = a * (Math.PI / 180)
|
||
const roll = Cesium.Math.fastApproximateAtan2(direction.x, direction.z);
|
||
// console.log({heading: heading * (180 / Math.PI), pitch: pitch * (180 / Math.PI), roll: roll * (180 / Math.PI)})
|
||
return { heading: Cesium.Math.TWO_PI - Cesium.Math.zeroToTwoPi(heading), pitch: pitch, roll: roll };
|
||
}
|
||
}
|
||
|
||
setMovePositionByDistance(distance) {
|
||
let positions_smooth = this._renewLine(this.options.line.positions)
|
||
this.modelMove(positions_smooth, { distance: distance })
|
||
}
|
||
|
||
setMovePositionByTime(time) {
|
||
let positions_smooth = this._renewLine(this.options.line.positions)
|
||
this.modelMove(positions_smooth, { time: time })
|
||
if (!this.state) {
|
||
this.modelMove(positions_smooth, { time: time+0.01 })
|
||
}
|
||
}
|
||
|
||
// 暂停
|
||
pause() {
|
||
this.state = false
|
||
}
|
||
|
||
// 继续
|
||
resume() {
|
||
this.state = true
|
||
}
|
||
|
||
async flyTo(options = {}) {
|
||
setActiveViewer(0)
|
||
closeRotateAround(this.sdk)
|
||
|
||
if (this.options.customView && this.options.customView.relativePosition && this.options.customView.orientation) {
|
||
let orientation = {
|
||
heading: Cesium.Math.toRadians(this.options.customView.orientation.heading || 0.0),
|
||
pitch: Cesium.Math.toRadians(this.options.customView.orientation.pitch || -60.0),
|
||
roll: Cesium.Math.toRadians(this.options.customView.orientation.roll || 0.0)
|
||
}
|
||
|
||
let lng = this.options.customView.relativePosition.lng
|
||
let lat = this.options.customView.relativePosition.lat
|
||
let alt = this.options.customView.relativePosition.alt
|
||
let destination = Cesium.Cartesian3.fromDegrees(lng, lat, alt)
|
||
|
||
let position = { lng: 0, lat: 0 }
|
||
position = { ...this.options.line.positions[0] }
|
||
// 如果没有高度值，则获取紧贴高度计算
|
||
if (!position.hasOwnProperty('alt')) {
|
||
position.alt = await this.getClampToHeight(position)
|
||
}
|
||
lng = this.options.customView.relativePosition.lng + position.lng
|
||
lat = this.options.customView.relativePosition.lat + position.lat
|
||
alt = this.options.customView.relativePosition.alt + position.alt
|
||
destination = Cesium.Cartesian3.fromDegrees(lng, lat, alt)
|
||
this.sdk.viewer.camera.flyTo({
|
||
destination: destination,
|
||
orientation: orientation
|
||
})
|
||
}
|
||
else {
|
||
this.line && this.sdk.viewer.flyTo(this.line, {
|
||
offset: options.orientation || {
|
||
heading: Cesium.Math.toRadians(0.0),
|
||
pitch: Cesium.Math.toRadians(-60.0),
|
||
roll: Cesium.Math.toRadians(0.0)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
remove() {
|
||
// this.sdk.viewer.scene.primitives.remove(this.model)
|
||
this.event && this.event.destroy()
|
||
this.tip && this.tip.destroy()
|
||
this.sdk.viewer.entities.remove(this.line)
|
||
this.line = null
|
||
this.removeModelAnimate()
|
||
}
|
||
|
||
reset() {
|
||
this.modelMove(this.line.polyline.positions._value)
|
||
this.state = false
|
||
this.current = this._first
|
||
}
|
||
|
||
// viewFollow(e) {
|
||
// if (e.target.checked) {
|
||
// var pointEntity = this.sdk.viewer.entities.add({
|
||
// // show: false,
|
||
// position: this.positions_smooth[0], // position of the point
|
||
// point: {
|
||
// color: Cesium.Color.RED.withAlpha(0), // color of the point
|
||
// pixelSize: 0
|
||
// }
|
||
// });
|
||
// this.sdk.viewer.trackedEntity = pointEntity;
|
||
// }
|
||
// else {
|
||
// this.sdk.viewer.entities.remove(this.sdk.viewer.trackedEntity)
|
||
// this.sdk.viewer.trackedEntity = null
|
||
// }
|
||
// }
|
||
|
||
// 移除动画
|
||
removeModelAnimate() {
|
||
if (this.TweenAnimate) {
|
||
clearTimeout(this.TweenAnimate.timeout)
|
||
TWEEN.remove(this.TweenAnimate)
|
||
this.TweenAnimate = null
|
||
}
|
||
// if (modelPrimitive && modelPrimitive._activeAnimations && modelPrimitive._activeAnimations._runtimeAnimations) {
|
||
// let runtimeAnimation = modelPrimitive._activeAnimations._runtimeAnimations
|
||
// for (let i = runtimeAnimation.length - 1; i >= 0; i--) {
|
||
// switch (runtimeAnimation[i].name) {
|
||
// case '跑':
|
||
// modelPrimitive.activeAnimations.remove(runtimeAnimation[i])
|
||
// break;
|
||
// default:
|
||
// }
|
||
// }
|
||
// }
|
||
}
|
||
|
||
|
||
_renewLine(pos) {
|
||
this.options.line.positions = pos
|
||
let positions = pos
|
||
if (this.noseToTail) {
|
||
positions = [...pos, pos[0]]
|
||
}
|
||
let fromDegreesArrayHeights = []
|
||
let time = []
|
||
let positions_smooth = []
|
||
for (let i = 0; i < positions.length; i++) {
|
||
fromDegreesArrayHeights.push(positions[i].lng, positions[i].lat, positions[i].alt)
|
||
time.push(i / (positions.length - 1))
|
||
}
|
||
if (this.smooth) {
|
||
this.spline = new Cesium.CatmullRomSpline({
|
||
times: time,
|
||
points: Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArrayHeights)
|
||
});
|
||
}
|
||
else {
|
||
this.spline = new Cesium.LinearSpline({
|
||
times: time,
|
||
points: Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArrayHeights)
|
||
});
|
||
}
|
||
for (let i = 0; i <= 100; i++) {
|
||
let cartesian3 = this.spline.evaluate(i / 100);
|
||
positions_smooth.push(cartesian3);
|
||
}
|
||
this.positions_smooth = positions_smooth
|
||
return positions_smooth
|
||
}
|
||
// 更新坐标
|
||
renewLinePositions(pos) {
|
||
this.options.line.positions = pos
|
||
let positions = pos
|
||
if (this.noseToTail) {
|
||
positions = [...pos, pos[0]]
|
||
}
|
||
let fromDegreesArrayHeights = []
|
||
let time = []
|
||
let positions_smooth = []
|
||
for (let i = 0; i < positions.length; i++) {
|
||
fromDegreesArrayHeights.push(positions[i].lng, positions[i].lat, positions[i].alt)
|
||
time.push(i / (positions.length - 1))
|
||
}
|
||
if (this.smooth) {
|
||
this.spline = new Cesium.CatmullRomSpline({
|
||
times: time,
|
||
points: Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArrayHeights)
|
||
});
|
||
}
|
||
else {
|
||
this.spline = new Cesium.LinearSpline({
|
||
times: time,
|
||
points: Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArrayHeights)
|
||
});
|
||
}
|
||
for (let i = 0; i <= 100; i++) {
|
||
let cartesian3 = this.spline.evaluate(i / 100);
|
||
positions_smooth.push(cartesian3);
|
||
}
|
||
this.positions_smooth = positions_smooth
|
||
if (this.line && this.line.polyline) {
|
||
this.line.polyline.positions = positions_smooth
|
||
}
|
||
return positions_smooth
|
||
}
|
||
|
||
flicker() { }
|
||
}
|
||
|
||
export default TrajectoryMotionObject |