@uni-sw/u-design 2.0.4

package/es/components/UMap/map/components/Track/index.js

@@ -0,0 +1,1051 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _regeneratorValues(e) { if (null != e) { var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"], r = 0; if (t) return t.call(e); if ("function" == typeof e.next) return e; if (!isNaN(e.length)) return { next: function next() { return e && r >= e.length && (e = void 0), { value: e && e[r++], done: !e }; } }; } throw new TypeError(_typeof(e) + " is not iterable"); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
+function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, _regeneratorDefine2(e, r, n, t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+/**
+ * @Description: 轨迹功能
+ * @author: 08472,07624
+ * @time: 2023-02-21
+ */
+
+import React, { useRef, forwardRef, useImperativeHandle } from 'react';
+import "./index.less";
+import { MAP_PULL_HEIGHT, MAP_TYPE } from "../../util/constants";
+import { colorToRgb, GUID } from "../../util/publicFun";
+import moment from 'moment';
+import { queryGisTrack, getDoorBatch, getSceneIndoorWay } from "../../api/MapApi";
+import DataBus from "../Bus/DataBus";
+import { DATAS_BUS_KEY } from "../Bus/BusKey";
+import { LogError } from "../../util/log";
+function MapTrack(props, resInstance) {
+  /** 地图控制类唯一key */
+  var instanceKey = props.instanceKey,
+    textLocale = props.textLocale;
+  /** 当前地图的真实MapControl对象 */
+  var realMapControl = useRef();
+  /** 地图对象 */
+  var map = useRef(null);
+  /** 地图数据总线实例，用于数据共享 */
+  var dataBusInstance = useRef(DataBus.GetInstance(instanceKey)).current;
+  /** 地图基本属性数据 */
+  var mapBaseData = useRef({
+    mapType: '',
+    sceneId: ''
+  });
+  /** 当前轨迹数据保存 */
+  var saveTrackList = useRef([]);
+
+  //#region 工具函数
+  /**
+  * 空函数，用于处理参数
+  */
+  var emptyFun = function emptyFun() {};
+  /**
+   * @method 根据第几层和建筑物id找高度
+   * @param {Number} floor 第几层
+   * @param {Number} buildingId 哪个建筑
+   */
+  function _findHeightInWorldByFloor(floor, buildingId) {
+    var models = realMapControl.current.getAllModelList();
+    var model = models.find(function (model) {
+      return model.floor === floor && model.buildingId === buildingId;
+    });
+    if (model && model.floor) {
+      if (model.floor !== 1) {
+        return model.height + MAP_PULL_HEIGHT * (model.floor - 1);
+      } else {
+        return model.height;
+      }
+    }
+    return;
+  }
+
+  /**
+   * @method 根据绑定的modelid找高度
+   * @param {Number} modelid 第几层
+   * @param {Number} height 原始高度
+   */
+  function _findHeightInWorldByModelId(modelId, height) {
+    var models = realMapControl.current.getAllModelList();
+    var model = models.find(function (model) {
+      return model.id === modelId;
+    });
+    if (model && model.floor) {
+      return height + MAP_PULL_HEIGHT * (model.floor - 1);
+    }
+    return height;
+  }
+
+  /**
+   * @method 更新地图数据
+   * @param {Object} obj 地图数据
+   */
+  var _updateMapData = function _updateMapData(_ref) {
+    var mapObj = _ref.mapObj,
+      mapType = _ref.mapType,
+      sceneId = _ref.sceneId,
+      mapControl = _ref.mapControl;
+    if (!mapObj) {
+      map.current = null;
+      mapBaseData.current = {
+        mapType: '',
+        sceneId: ''
+      };
+    } else {
+      map.current = mapObj;
+      mapBaseData.current = {
+        mapType: mapType,
+        sceneId: sceneId
+      };
+      realMapControl.current = mapControl;
+    }
+  };
+
+  /**
+   * 是否有轨迹
+   */
+  function hasTrack() {
+    return saveTrackList.current.length > 0;
+  }
+  //#endregion
+
+  //#region 清除功能
+  /**
+   * @method 清除轨迹数据在切换地图时调用
+   */
+  var clearTrackByMap = function clearTrackByMap() {
+    if (!map.current) {
+      return;
+    }
+    //清除轨迹
+    saveTrackList.current.forEach(function (element) {
+      // 存在轨迹id表示轨迹已经被绘制了，需要删除
+      if (element.trackId) {
+        map.current.removeTrack(element.trackId);
+      }
+    });
+    // 清空轨迹数据
+    saveTrackList.current = [];
+  };
+
+  /**
+   * @method 清除单条轨迹
+   * @param {String} 轨迹id
+   */
+  var clearTrack = function clearTrack(drawId) {
+    if (!map.current) return;
+    if (!drawId) {
+      return;
+    }
+    if (typeof drawId === 'string') {
+      drawId = [drawId];
+    }
+    var saveTrackListLen = saveTrackList.current.length - 1;
+    for (var i = saveTrackListLen; i >= 0; i--) {
+      var element = saveTrackList.current[i];
+      // 根据drawid寻找需要删除的地图轨迹id
+      if (drawId.indexOf(element.id) !== -1) {
+        // 有轨迹id，同时删除轨迹
+        if (element.trackId) {
+          map.current.removeTrack(element.trackId);
+        }
+        // 直接将轨迹从数组中删除
+        saveTrackList.current.splice(i, 1);
+      }
+    }
+    var mapType = mapBaseData.current.mapType;
+    // 如果轨迹已经全部删除且是场景地图，需要退出轨迹状态
+    if (saveTrackList.current.length <= 0 && (mapType === MAP_TYPE.scene || mapType === MAP_TYPE.stream)) {
+      // 获取视角信息，跳到正常地图默认视角
+      var floor = dataBusInstance.getData(DATAS_BUS_KEY.currentFloor);
+      realMapControl.current.jumpScreenViewFromDraw(floor ? floor.angleInfo : undefined);
+    }
+  };
+  //#endregion
+
+  //#region 绘制相关函数
+  /**
+   * @method 设置轨迹样式
+   */
+  var _setTrackStyle = function _setTrackStyle() {
+    var trackStyle = {
+      color: colorToRgb('#409eff'),
+      width: 5
+    };
+    return trackStyle;
+  };
+
+  /**
+   * @method 轨迹绘制成功设置地图id
+   * @param {String} trackId 轨迹地图上id
+   * @param {String} drawId 轨迹绘制id
+   */
+  var _setTrackId = function _setTrackId(trackId, drawId) {
+    // 绘制轨迹数据的index
+    var index = -1;
+    for (var i = 0; i < saveTrackList.current.length; i++) {
+      var element = saveTrackList.current[i];
+      if (element.id === drawId) {
+        index = i;
+        break;
+      }
+    }
+    if (index === -1) {
+      return;
+    }
+    // 更新当前轨迹的地图id
+    saveTrackList.current[index].trackId = trackId;
+  };
+
+  /**
+   * 2d轨迹绘制
+   * @param {Object} trackParam 外部绘制轨迹数据
+   */
+  var _drawTrackIn2D = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(trackParam) {
+      var track, trackStyle, failCallback, succCallback, drawId, _trackParam$speed, speed, deviceData, trackData, i, _track$i, _track$i$passTimeYS, passTimeYS, coordinateX, coordinateY, time, _i, _mapBaseData$current, mapType, sceneId, _trackParam, res, _result, newTrackInfo, allDis, indexs, startTime, _i3, element, elementPre, distance, j, point, index, result, trackId;
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.n) {
+          case 0:
+            track = trackParam.track, trackStyle = trackParam.trackStyle, failCallback = trackParam.failCallback, succCallback = trackParam.succCallback, drawId = trackParam.drawId, _trackParam$speed = trackParam.speed, speed = _trackParam$speed === void 0 ? 1 : _trackParam$speed;
+            deviceData = []; // 点位数据，返回位置信息
+            if (map.current) {
+              _context.n = 1;
+              break;
+            }
+            return _context.a(2);
+          case 1:
+            if (Array.isArray(track)) {
+              _context.n = 2;
+              break;
+            }
+            LogError('轨迹点位数据参数错误');
+            return _context.a(2);
+          case 2:
+            trackData = []; // 首次处理需要绘制的点位数据，用于过滤无效信息
+            for (i = 0; i < track.length; i++) {
+              _track$i = track[i], _track$i$passTimeYS = _track$i.passTimeYS, passTimeYS = _track$i$passTimeYS === void 0 ? '2020-02-02 22:22:22' : _track$i$passTimeYS, coordinateX = _track$i.coordinateX, coordinateY = _track$i.coordinateY; // 计算点位经过时间
+              time = moment(passTimeYS).diff(moment(track[0].passTimeYS || '2020-02-02 22:22:22'), 'seconds');
+              trackData.push({
+                coord: [coordinateX, coordinateY, 0],
+                time: time,
+                passTimeYS: passTimeYS
+              });
+            }
+            if (trackData.length > 1 && !trackData[1].time) {
+              // 未传入抓拍时间
+              for (_i = 0; _i < trackData.length; _i++) {
+                trackData[_i].time = _i * 5;
+              }
+            }
+            // gis类型需要查询路网数据
+            _mapBaseData$current = mapBaseData.current, mapType = _mapBaseData$current.mapType, sceneId = _mapBaseData$current.sceneId;
+            if (!(mapType === MAP_TYPE.gis)) {
+              _context.n = 4;
+              break;
+            }
+            // 需要请求的轨迹参数
+            _trackParam = track.map(function (item) {
+              var position = map.current.gcj02towgs84({
+                lng: item.coordinateX,
+                lat: item.coordinateY
+              });
+              return {
+                Lng: position.Coord.lng,
+                Lat: position.Coord.lat,
+                Time: item.passTimeYS || '2020-02-02 22:22:22'
+              };
+            }); // 返回的查询结果
+            _context.n = 3;
+            return queryGisTrack({
+              Points: _trackParam,
+              IsScene: !!sceneId,
+              SceneID: sceneId
+            });
+          case 3:
+            res = _context.v;
+            _result = res ? res.data : {
+              ErrCode: -1
+            };
+            newTrackInfo = [];
+            if (_result.ErrCode === 0) {
+              _result.TrajectoryItems.forEach(function (item) {
+                var points = [];
+                //先转回火星,去除相邻重复
+                item.Points.unshift(_objectSpread(_objectSpread({}, item.StartPoint), {}, {
+                  passTimeYS: item.StartTime
+                }));
+                item.Points.push(_objectSpread(_objectSpread({}, item.EndPoint), {}, {
+                  passTimeYS: item.EndTime
+                }));
+                for (var _i2 = 0; _i2 < item.Points.length; _i2++) {
+                  var point = item.Points[_i2];
+                  var _map$current$wgs84tog = map.current.wgs84togcj02({
+                      lng: point.Lng,
+                      lat: point.Lat
+                    }).Coord,
+                    lng = _map$current$wgs84tog.lng,
+                    lat = _map$current$wgs84tog.lat;
+                  point.lng = lng;
+                  point.lat = lat;
+                  points.push(point);
+                }
+                newTrackInfo = newTrackInfo.concat(points.map(function (point) {
+                  return {
+                    coord: [point.lng, point.lat, 0],
+                    passTimeYS: point.passTimeYS
+                  };
+                }));
+              });
+              // 去重重复点位
+              trackData = newTrackInfo.reduce(function (pre, cur) {
+                if (pre.length !== 0) {
+                  var preItem = pre[pre.length - 1];
+                  var str = preItem.coord.join(',');
+                  var str2 = cur.coord.join(',');
+                  if (str !== str2) {
+                    pre.push(cur);
+                  } else {
+                    if (cur.passTimeYS && preItem.passTimeYS === undefined) {
+                      preItem.passTimeYS = cur.passTimeYS;
+                    }
+                  }
+                } else {
+                  pre.push(cur);
+                }
+                return pre;
+              }, []);
+              // 先获取每个时间段总距离
+              allDis = 0;
+              indexs = [];
+              startTime = 0;
+              for (_i3 = 0; _i3 < trackData.length; _i3++) {
+                element = trackData[_i3];
+                elementPre = trackData[_i3 - 1];
+                if (_i3 === 0) {
+                  element.time = 0;
+                } else {
+                  distance = map.current.measureDistanceNoHeight({
+                    lng: elementPre.coord[0],
+                    lat: elementPre.coord[1]
+                  }, {
+                    lng: element.coord[0],
+                    lat: element.coord[1]
+                  }).Distance;
+                  allDis += distance;
+                  element.allDis = allDis;
+                  if (element.passTimeYS) {
+                    element.time = moment(element.passTimeYS).diff(moment(trackData[0].passTimeYS), 'seconds');
+                    // 更新整个时间段每个点的时间
+                    for (j = 0; j < indexs.length; j++) {
+                      point = trackData[indexs[j]];
+                      point.time = point.allDis / allDis * (element.time - startTime) + startTime;
+                    }
+                    allDis = 0; // 总距离重新计数
+                    startTime = element.time; // 当前时间为下次的开始时间
+                    indexs = []; // 更新时间段的索引
+                  } else {
+                    indexs.push(_i3);
+                  }
+                }
+              }
+            }
+          case 4:
+            // 判断轨迹是否被删除，是直接不进行操作
+            index = saveTrackList.current.findIndex(function (item) {
+              return item.id === drawId;
+            });
+            if (!(index === -1)) {
+              _context.n = 5;
+              break;
+            }
+            return _context.a(2);
+          case 5:
+            // 设置返回的点位数据
+            deviceData = track.map(function (item) {
+              var deviceCode = item.deviceCode,
+                _item$coordinateZ = item.coordinateZ,
+                coordinateZ = _item$coordinateZ === void 0 ? 0 : _item$coordinateZ;
+              return {
+                lng: item.coordinateX,
+                lat: item.coordinateY,
+                height: coordinateZ,
+                deviceCode: deviceCode
+              };
+            });
+            result = map.current.addTrack({
+              trackData: trackData,
+              trackStyle: trackStyle,
+              speed: speed
+            });
+            if (result.ErrCode === 0) {
+              trackId = result.Id;
+              _setTrackId(trackId, drawId);
+              succCallback(trackId, drawId, deviceData);
+            } else {
+              failCallback(textLocale.drawingTrackFailed || '绘制轨迹失败' + result.ErrMsg);
+            }
+          case 6:
+            return _context.a(2);
+        }
+      }, _callee);
+    }));
+    return function _drawTrackIn2D(_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+
+  /**
+   * 获取场景地图轨迹数据
+   * @param {string[]} buildingIDList 轨迹涉及建筑物id数组
+   * @param {string} sceneId 场景id
+   * @param {object} trackInfo 轨迹信息
+   * @returns
+   */
+  var getSceneIndoorWayData = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(buildingIDList, sceneId, trackInfo) {
+      var doorList, res, i, doorArray, j, fetchDataArr, fetchReqArr, fetchReqJ, newTrackInfo, _loop, _i4, _t, _t2;
+      return _regenerator().w(function (_context3) {
+        while (1) switch (_context3.p = _context3.n) {
+          case 0:
+            //获取出口
+            doorList = []; // 如果是建筑物轨迹需要查询建筑物出入口
+            if (!(buildingIDList.length > 0)) {
+              _context3.n = 4;
+              break;
+            }
+            _context3.p = 1;
+            _context3.n = 2;
+            return getDoorBatch({
+              sceneID: sceneId,
+              buildingIDList: buildingIDList
+            });
+          case 2:
+            res = _context3.v;
+            doorList = res;
+            _context3.n = 4;
+            break;
+          case 3:
+            _context3.p = 3;
+            _t = _context3.v;
+            doorList = null;
+          case 4:
+            if (doorList) {
+              _context3.n = 5;
+              break;
+            }
+            return _context3.a(2, trackInfo.map(function (item) {
+              // 获取点位拉开后高度
+              var height = _findHeightInWorldByModelId(item.modelId, item.height) + 0.1;
+              item.height = height;
+              return {
+                coord: [item.Lng, item.Lat, item.height],
+                modelId: item.modelId,
+                time: item.time
+              };
+            }));
+          case 5:
+            //先塞门
+            i = 0;
+            while (i <= trackInfo.length - 2) {
+              // 循环点位获取门插入的位置
+              if (trackInfo[i].buildingId !== trackInfo[i + 1].buildingId && !trackInfo[i].isdoor && !trackInfo[i + 1].isdoor) {
+                doorArray = doorList.filter(function (door) {
+                  return door.buildingId === trackInfo[i].buildingId || door.buildingId === trackInfo[i + 1].buildingId;
+                });
+                doorArray[0].buildingId !== trackInfo[i].buildingId && doorArray.reverse();
+                //楼之间跳转，寻求两扇门
+                trackInfo.splice.apply(trackInfo, [i + 1, 0].concat(_toConsumableArray(doorArray)));
+              }
+              i++;
+            }
+            //求出路网走法
+            j = 0;
+            fetchDataArr = []; // 并发请求路网数据数组
+            fetchReqArr = []; // 请求的点位数组，用于匹配重复数据
+            fetchReqJ = []; // 请求的点位应该插入的位置数组，用于获取插入的位置
+            newTrackInfo = []; // 最终轨迹数据
+            _context3.p = 6;
+            _loop = /*#__PURE__*/_regenerator().m(function _loop() {
+              var mode, trackParam, req, stringifyReq, hasFetchReq;
+              return _regenerator().w(function (_context2) {
+                while (1) switch (_context2.n) {
+                  case 0:
+                    if (trackInfo[_i4].isdoor || _i4 === trackInfo.length - 1) {
+                      mode = 'world';
+                      trackParam = trackInfo.slice(j, _i4 + 1).map(function (item) {
+                        item = _objectSpread({}, item);
+                        //存在建筑里的点则是室内路网计算
+                        if (item.buildingId && !item.isdoor) {
+                          mode = 'indoor';
+                        }
+                        delete item.isdoor;
+                        return item;
+                      }); //室内点，并且不是跨建筑
+                      if (mode === 'indoor') {
+                        // 经纬度转整型
+                        trackParam = trackParam.map(function (iTemp) {
+                          return _objectSpread(_objectSpread({}, iTemp), {}, {
+                            Lat: Number(iTemp.Lat),
+                            Lng: Number(iTemp.Lng)
+                          });
+                        });
+                        req = {
+                          Points: trackParam,
+                          SceneID: sceneId,
+                          BuildingID: trackInfo[j].buildingId
+                        };
+                        stringifyReq = JSON.stringify(req);
+                        hasFetchReq = fetchReqArr.findIndex(function (el) {
+                          return el === stringifyReq;
+                        }); // 如果没有请求过，需要进行请求
+                        if (hasFetchReq === -1) {
+                          fetchDataArr.push(getSceneIndoorWay({
+                            Points: trackParam,
+                            SceneID: sceneId,
+                            BuildingID: trackInfo[j].buildingId
+                          }));
+                          fetchReqArr.push(stringifyReq);
+                          fetchReqJ.push(j);
+                        } else {
+                          // 已经请求过了就直接返回对应请求过的index
+                          fetchDataArr.push(Promise.resolve(hasFetchReq));
+                          // push一个空元素进行占位
+                          fetchReqArr.push(null);
+                          fetchReqJ.push(j);
+                        }
+                      } else {
+                        // 直接将返回值放入请求数组
+                        fetchDataArr.push(Promise.resolve(trackParam));
+                        // push一个空元素进行占位
+                        fetchReqArr.push(null);
+                        fetchReqJ.push(null);
+                      }
+                      j = _i4;
+                    }
+                  case 1:
+                    return _context2.a(2);
+                }
+              }, _loop);
+            });
+            _i4 = 0;
+          case 7:
+            if (!(_i4 < trackInfo.length)) {
+              _context3.n = 9;
+              break;
+            }
+            return _context3.d(_regeneratorValues(_loop()), 8);
+          case 8:
+            _i4++;
+            _context3.n = 7;
+            break;
+          case 9:
+            _context3.n = 10;
+            return Promise.all(fetchDataArr).then(function (resArr) {
+              var _loop2 = function _loop2(_i5) {
+                var result = resArr[_i5];
+                // 请求数据的类型
+                if (fetchReqArr[_i5]) {
+                  var trackPoints = JSON.parse(fetchReqArr[_i5]).Points;
+                  var resData = result.data;
+                  if (resData.ErrCode === 0) {
+                    resData.Ways.forEach(function (item, itemIndex) {
+                      item.forEach(function (point, pointIndex) {
+                        var height = _findHeightInWorldByFloor(point.Floor, trackInfo[fetchReqJ[_i5]].buildingId) + 0.1;
+                        for (var k = 0; k < point.Lines.length; k++) {
+                          var element = point.Lines[k];
+                          var trakPoint = {
+                            coord: [].concat(_toConsumableArray(element), [height]),
+                            modelId: item.modelId
+                          };
+                          if (pointIndex === 0 && k === 0) {
+                            if (trackPoints[itemIndex].time) {
+                              trakPoint.time = trackPoints[itemIndex].time;
+                            }
+                          }
+                          // 最后一个item的最后一个点需要拼接点位
+                          if (itemIndex === resData.Ways.length - 1 && pointIndex === item.length - 1 && k === point.Lines.length - 1) {
+                            // 是设备需要拼接
+                            if (trackPoints[itemIndex + 1].time) {
+                              trakPoint.time = trackPoints[itemIndex + 1].time;
+                            }
+                          }
+                          newTrackInfo.push(trakPoint);
+                        }
+                      });
+                    });
+                  } else {
+                    throw '查询室内路网失败';
+                  }
+                } else if (typeof result === 'number') {
+                  // 数字表示去对应请求的索引值
+                  var _trackPoints = JSON.parse(fetchReqArr[result]).Points;
+                  var _resData = resArr[result].data;
+                  _resData.Ways.forEach(function (item, itemIndex) {
+                    item.forEach(function (point, pointIndex) {
+                      var height = _findHeightInWorldByFloor(point.Floor, trackInfo[fetchReqJ[_i5]].buildingId) + 0.1;
+                      for (var k = 0; k < point.Lines.length; k++) {
+                        var element = point.Lines[k];
+                        var trakPoint = {
+                          coord: [].concat(_toConsumableArray(element), [height]),
+                          modelId: item.modelId
+                        };
+                        if (pointIndex === 0 && k === 0) {
+                          if (_trackPoints[itemIndex].time) {
+                            trakPoint.time = _trackPoints[itemIndex].time;
+                          }
+                        }
+                        // 最后一个item的最后一个点需要拼接点位
+                        if (itemIndex === _resData.Ways.length - 1 && pointIndex === item.length - 1 && k === point.Lines.length - 1) {
+                          // 是设备需要拼接
+                          if (_trackPoints[itemIndex + 1].time) {
+                            trakPoint.time = _trackPoints[itemIndex + 1].time;
+                          }
+                        }
+                        newTrackInfo.push(trakPoint);
+                      }
+                    });
+                  });
+                } else {
+                  // 室外点类型
+                  result.forEach(function (item) {
+                    newTrackInfo.push({
+                      coord: [item.Lng, item.Lat, 1],
+                      modelId: item.modelId,
+                      time: item.time
+                    });
+                  });
+                }
+              };
+              // 根据不同类型进行数据拼接
+              for (var _i5 = 0; _i5 < resArr.length; _i5++) {
+                _loop2(_i5);
+              }
+            });
+          case 10:
+            _context3.n = 12;
+            break;
+          case 11:
+            _context3.p = 11;
+            _t2 = _context3.v;
+            LogError(_t2);
+            return _context3.a(2, trackInfo.map(function (item) {
+              // 获取点位拉开后高度
+              var height = _findHeightInWorldByModelId(item.modelId, item.height) + 0.1;
+              item.height = height;
+              return {
+                coord: [item.Lng, item.Lat, item.height],
+                modelId: item.modelId,
+                time: item.time
+              };
+            }));
+          case 12:
+            return _context3.a(2, newTrackInfo.reduce(function (pre, cur) {
+              if (pre.length !== 0) {
+                var preItem = pre[pre.length - 1];
+                var str = preItem.coord.join(',');
+                var str2 = cur.coord.join(',');
+                if (str !== str2) {
+                  pre.push(cur);
+                } else {
+                  if (cur.time && preItem.time === undefined) {
+                    preItem.time = cur.time;
+                  }
+                }
+              } else {
+                pre.push(cur);
+              }
+              return pre;
+            }, []));
+        }
+      }, _callee2, null, [[6, 11], [1, 3]]);
+    }));
+    return function getSceneIndoorWayData(_x2, _x3, _x4) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
+  /**
+   * @method 场景云渲染轨迹绘制
+   * @param {Object} trackParam 外部绘制轨迹数据
+   * @param {Object} trackStyle 轨迹样式
+   */
+  var _drawWorldByApi = /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(trackParam) {
+      var track, trackStyle, failCallback, succCallback, drawId, _trackParam$speed2, speed, _mapBaseData$current2, sceneId, mapType, trackInfo, buildingIDList, _loop3, i, newTrackInfo, deviceData, _i6, allDis, indexs, startTime, _i7, element, elementPre, distance, j, point, tStyle, result, trackId, index, _index, _result2, _trackId;
+      return _regenerator().w(function (_context5) {
+        while (1) switch (_context5.n) {
+          case 0:
+            track = trackParam.track, trackStyle = trackParam.trackStyle, failCallback = trackParam.failCallback, succCallback = trackParam.succCallback, drawId = trackParam.drawId, _trackParam$speed2 = trackParam.speed, speed = _trackParam$speed2 === void 0 ? 1 : _trackParam$speed2;
+            _mapBaseData$current2 = mapBaseData.current, sceneId = _mapBaseData$current2.sceneId, mapType = _mapBaseData$current2.mapType;
+            trackInfo = []; // 首次处理需要绘制的点位数据，用于过滤无效信息
+            buildingIDList = []; // 全部建筑物id，用于获取建筑物出入口
+            _loop3 = /*#__PURE__*/_regenerator().m(function _loop3() {
+              var _track$i2, buildingId, coordinateX, coordinateY, coordinateZ, floor, deviceCode, modelId, _track$i2$passTimeYS, passTimeYS, height, time, temp;
+              return _regenerator().w(function (_context4) {
+                while (1) switch (_context4.n) {
+                  case 0:
+                    _track$i2 = track[i], buildingId = _track$i2.buildingId, coordinateX = _track$i2.coordinateX, coordinateY = _track$i2.coordinateY, coordinateZ = _track$i2.coordinateZ, floor = _track$i2.floor, deviceCode = _track$i2.deviceCode, modelId = _track$i2.modelId, _track$i2$passTimeYS = _track$i2.passTimeYS, passTimeYS = _track$i2$passTimeYS === void 0 ? '2020-02-02 22:22:22' : _track$i2$passTimeYS;
+                    height = coordinateZ; // 时间
+                    time = moment(passTimeYS).diff(moment(track[0].passTimeYS || '2020-02-02 22:22:22'), 'seconds'); //在建筑上面
+                    temp = {
+                      Lng: coordinateX,
+                      Lat: coordinateY,
+                      height: height,
+                      deviceCode: deviceCode,
+                      modelId: modelId,
+                      passTimeYS: passTimeYS,
+                      time: time
+                    };
+                    if (buildingId && floor) {
+                      temp.buildingId = buildingId;
+                      temp.Floor = floor;
+                      temp.height = height;
+                      if (!buildingIDList.find(function (buildId) {
+                        return buildId === buildingId;
+                      })) {
+                        buildingIDList.push(buildingId);
+                      }
+                    }
+                    trackInfo.push(temp);
+                  case 1:
+                    return _context4.a(2);
+                }
+              }, _loop3);
+            });
+            i = 0;
+          case 1:
+            if (!(i < track.length)) {
+              _context5.n = 3;
+              break;
+            }
+            return _context5.d(_regeneratorValues(_loop3()), 2);
+          case 2:
+            i++;
+            _context5.n = 1;
+            break;
+          case 3:
+            newTrackInfo = []; // 绘制的轨迹数据
+            deviceData = []; // 点位数据，返回位置信息
+            if (trackInfo.length > 1 && !trackInfo[1].time) {
+              // 未传入抓拍时间
+              for (_i6 = 0; _i6 < trackInfo.length; _i6++) {
+                trackInfo[_i6].time = _i6 * 5;
+              }
+            }
+            // 若存在路网
+            if (!(mapType === MAP_TYPE.scene)) {
+              _context5.n = 5;
+              break;
+            }
+            _context5.n = 4;
+            return getSceneIndoorWayData(buildingIDList, sceneId, trackInfo);
+          case 4:
+            newTrackInfo = _context5.v;
+            _context5.n = 6;
+            break;
+          case 5:
+            newTrackInfo = trackInfo.map(function (item) {
+              var _item$modelId;
+              // 获取点位拉开后高度
+              var height = _findHeightInWorldByModelId(item.modelId, item.height) + 0.1;
+              return {
+                coord: [item.Lng, item.Lat, height],
+                modelId: (_item$modelId = item.modelId) !== null && _item$modelId !== void 0 ? _item$modelId : '',
+                time: item.time || 0
+              };
+            });
+          case 6:
+            // 场景地图单独处理轨迹时间
+            if (mapType === MAP_TYPE.scene) {
+              // 先获取每个时间段总距离
+              allDis = 0;
+              indexs = [];
+              startTime = 0;
+              for (_i7 = 0; _i7 < newTrackInfo.length; _i7++) {
+                element = newTrackInfo[_i7];
+                elementPre = newTrackInfo[_i7 - 1];
+                if (_i7 === 0) {
+                  element.time = 0;
+                } else {
+                  distance = map.current.measureDistanceWithHeight({
+                    lng: elementPre.coord[0],
+                    lat: elementPre.coord[1],
+                    height: elementPre.coord[2]
+                  }, {
+                    lng: element.coord[0],
+                    lat: element.coord[1],
+                    height: element.coord[2]
+                  }).Distance;
+                  allDis += distance;
+                  element.allDis = allDis;
+                  if (element.time) {
+                    // 更新整个时间段每个点的时间
+                    for (j = 0; j < indexs.length; j++) {
+                      point = newTrackInfo[indexs[j]];
+                      point.time = point.allDis / allDis * (element.time - startTime) + startTime;
+                    }
+                    allDis = 0; // 总距离重新计数
+                    startTime = element.time; // 当前时间为下次的开始时间
+                    indexs = []; // 更新时间段的索引
+                  } else {
+                    indexs.push(_i7);
+                  }
+                }
+              }
+            }
+            deviceData = trackInfo.map(function (item, index) {
+              var modelId = item.modelId,
+                passTimeYS = item.passTimeYS,
+                deviceCode = item.deviceCode;
+              var height = _findHeightInWorldByModelId(item.modelId, item.height);
+              return {
+                lng: item.Lng,
+                lat: item.Lat,
+                height: height,
+                deviceCode: deviceCode,
+                passTimeYS: passTimeYS,
+                modelId: modelId,
+                time: item.time
+              };
+            }).filter(function (item) {
+              return !!item.deviceCode;
+            });
+            tStyle = _objectSpread({}, trackStyle); // 云渲染需要控制异步逻辑
+            if (!(mapType === MAP_TYPE.stream)) {
+              _context5.n = 8;
+              break;
+            }
+            // 云渲染的颜色需要单独处理
+            tStyle.color = "rgba(".concat(tStyle.color[0], ",").concat(tStyle.color[1], ",").concat(tStyle.color[2], ",").concat(tStyle.color[3], ")");
+            // 如果未传图片和模型，设置云渲染为仅线模式
+            if (!tStyle.image && !tStyle.model) {
+              tStyle.onlyLine = true;
+            }
+            // 云渲染为异步绘制，需要在绘制完之后在删除
+            _context5.n = 7;
+            return map.current.addTrack({
+              trackData: newTrackInfo,
+              trackStyle: tStyle,
+              speed: speed
+            });
+          case 7:
+            result = _context5.v;
+            if (result.ErrCode === 0) {
+              trackId = result.Id;
+              index = saveTrackList.current.findIndex(function (item) {
+                return item.id === drawId;
+              }); // 轨迹未被删除可以绘制成功
+              if (index !== -1) {
+                _setTrackId(trackId, drawId);
+                succCallback(trackId, drawId, deviceData);
+              } else {
+                map.current.removeTrack(trackId);
+              }
+            } else {
+              failCallback(textLocale.loadingSceneTrackFailed || '加载场景轨迹失败' + result.ErrMsg);
+            }
+            _context5.n = 10;
+            break;
+          case 8:
+            // 判断轨迹是否被删除，是直接不进行绘制
+            _index = saveTrackList.current.findIndex(function (item) {
+              return item.id === drawId;
+            });
+            if (!(_index === -1)) {
+              _context5.n = 9;
+              break;
+            }
+            return _context5.a(2);
+          case 9:
+            _result2 = map.current.addTrack({
+              trackData: newTrackInfo,
+              trackStyle: tStyle,
+              speed: speed
+            });
+            if (_result2.ErrCode === 0) {
+              _trackId = _result2.Id;
+              _setTrackId(_trackId, drawId);
+              succCallback(_trackId, drawId, deviceData);
+            } else {
+              failCallback(textLocale.loadingSceneTrackFailed || '加载场景轨迹失败' + _result2.ErrMsg);
+            }
+          case 10:
+            return _context5.a(2);
+        }
+      }, _callee3);
+    }));
+    return function _drawWorldByApi(_x5) {
+      return _ref4.apply(this, arguments);
+    };
+  }();
+
+  /**
+   * @method 处理轨迹数据
+   * @param {Array} data 轨迹数据
+   * @param {number} mapType 地图类型
+   */
+  var _dealTrackDataBuildId = function _dealTrackDataBuildId() {
+    var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var mapType = arguments.length > 1 ? arguments[1] : undefined;
+    if (!data.length) return data; // 无数据则返回
+    // 计算时间
+    var timeArr = [];
+    var dataInTime = data.map(function (item, index) {
+      var time = 0;
+      if (index > 0) {
+        try {
+          time = (new Date(item.passTimeYS).getTime() - new Date(data[index - 1].passTimeYS).getTime()) / 1000;
+        } catch (error) {
+          time = timeArr[index - 1];
+        }
+      }
+      timeArr.push(time);
+      return _objectSpread(_objectSpread({}, item), {}, {
+        time: time
+      });
+    });
+    // 2d地图 处理得到时间后直接返回
+    if (mapType === MAP_TYPE.gis || mapType === MAP_TYPE.plane) return dataInTime;
+    // 获取所有建筑列表
+    // const buildObjs = realMapControl.current.getAllBuildlList();
+    // 3d地图执行拉开再绘制轨迹
+    if (mapType === MAP_TYPE.scene) {
+      var modelList = realMapControl.current.getAllModelList();
+      var nData = []; // 需要绘制轨迹数据
+      var count = dataInTime.length;
+      var _loop4 = function _loop4() {
+        var modelId = dataInTime[index].modelId;
+        var obj = null;
+        if (modelId) {
+          obj = modelList.find(function (item) {
+            return item.id === modelId;
+          });
+        }
+        if (obj) {
+          nData.push(_objectSpread(_objectSpread({}, dataInTime[index]), {}, {
+            buildingId: obj.buildingId,
+            floor: obj.floor
+          }));
+        }
+      };
+      for (var index = 0; index < count; index++) {
+        _loop4();
+      }
+      return nData;
+    }
+    // 云引擎执行拉开
+    if (mapType === MAP_TYPE.stream || mapType === MAP_TYPE.model) {
+      return dataInTime;
+    }
+  };
+
+  /**
+   * @method 绘制轨迹
+   * @param {Array} track 所有的轨迹点
+   * @param {Function} failCallback 失败回调
+   * @param {Function} succCallback 成功回调
+   * @param {Array} track 所有的轨迹点
+   * @param {String} sTrackId 指定轨迹id 再拉开/回重绘时用得到 新创建将不会有
+   */
+  function _drawTrack(_ref5, sTrackId) {
+    var track = _ref5.track,
+      trackStyle = _ref5.trackStyle,
+      failCallback = _ref5.failCallback,
+      succCallback = _ref5.succCallback,
+      drawId = _ref5.drawId,
+      _ref5$speed = _ref5.speed,
+      speed = _ref5$speed === void 0 ? 1 : _ref5$speed;
+    var mapType = mapBaseData.current.mapType;
+    // 判断是否可以绘制轨迹
+    var trackInMap = _dealTrackDataBuildId(track, mapType);
+    //一个形成不了轨迹
+    if (trackInMap.length === 1) {
+      typeof failCallback === 'function' && failCallback(textLocale.trackPointLimit || '轨迹需要两个及以上的点');
+      return;
+    }
+    // 相同点位形成不了轨迹
+    var hasDiffPoint = false;
+    for (var i = 0; i < trackInMap.length - 1; i++) {
+      var element = trackInMap[i];
+      var elementNext = trackInMap[i + 1];
+      if (element.coordinateX !== elementNext.coordinateX || element.coordinateY !== elementNext.coordinateY || element.coordinateZ !== elementNext.coordinateZ || element.modelId !== elementNext.modelId) {
+        hasDiffPoint = true;
+        break;
+      }
+    }
+    if (!hasDiffPoint) {
+      typeof failCallback === 'function' && failCallback(textLocale.trackRepeatPoint || '重复点位数据无法绘制轨迹');
+      return;
+    }
+    // 设置默认轨迹样式
+    var trackStyleT = trackStyle || _setTrackStyle();
+    trackInMap = trackInMap.map(function (item, index) {
+      return _objectSpread(_objectSpread({}, item), {}, {
+        index: index,
+        coordinateX: Number(item.coordinateX),
+        coordinateY: Number(item.coordinateY),
+        coordinateZ: Number(item.coordinateZ || 0)
+      });
+    });
+    var prams = {
+      track: trackInMap,
+      trackStyle: trackStyleT,
+      failCallback: failCallback || emptyFun,
+      succCallback: succCallback || emptyFun,
+      drawId: drawId,
+      speed: speed
+    };
+    if (!trackInMap.length) return;
+    saveTrackList.current.push({
+      id: drawId,
+      trackParam: prams,
+      // 轨迹传入参数
+      trackId: '' // 轨迹地图id
+    });
+    // 轨迹数据保存
+    if (mapType === MAP_TYPE.scene || mapType === MAP_TYPE.stream) {
+      //场景轨迹
+      _drawWorldByApi(prams, sTrackId);
+      // 还需要拉开建筑物
+      realMapControl.current.pullAllModelToDraw();
+    } else {
+      _drawTrackIn2D(prams, sTrackId);
+    }
+  }
+  //#endregion
+
+  useImperativeHandle(resInstance, function () {
+    return {
+      // 更新地图对象
+      updateMapData: _updateMapData,
+      clearTrackByMap: clearTrackByMap,
+      hasTrack: hasTrack,
+      // 单条轨迹绘制
+      drawTrack: function drawTrack(params) {
+        // 生成轨迹绘制id
+        var id = GUID();
+        params.drawId = id;
+        _drawTrack(params);
+        return id;
+      },
+      // 单条轨迹清除
+      clearTrack: clearTrack
+    };
+  });
+  return /*#__PURE__*/React.createElement(React.Fragment, null);
+}
+export default /*#__PURE__*/forwardRef(MapTrack);