traffic-laser/src/graphic/Load.js

import { dataService } from "./Service/DataService.js";
import { stateService } from "./Service/StateService.js";
import { coordinate } from "./Coordinate.js";
import Constant from "./Constant";
import { tagService } from "./Service/TagService";
import { mathUtil } from "./Util/MathUtil";
import { measureService } from "./Service/MeasureService";
import { cameraService } from "./Service/CameraService";

export default class Load {
  constructor(layer) {
    this.layer = layer;
    this.version = "v1.0";
    this.vectorsJson = null;
    this.newVectorId = null;
  }

  load(floors) {
    for (let i = 0; i < floors.length; ++i) {
      let floor = floors[i];
      let subgroup = i;
      if (floor.hasOwnProperty("subgroup")) {
        subgroup = floor.subgroup;
      }
      dataService.initFloor(subgroup);
      dataService.setCurrentFloor(subgroup);
      for (let key in floor.points) {
        wallService.createPoint(
          floor.points[key].x,
          floor.points[key].y,
          floor.points[key].vectorId,
          subgroup
        );
      }

      for (let key in floor.walls) {
        let wall = wallService.createWall(
          floor.walls[key].start,
          floor.walls[key].end,
          floor.walls[key].vectorId,
          subgroup
        );
        wall.setImportant(floor.walls[key].important);
        wall.setOut(floor.walls[key].out);
        wall.setChildren(floor.walls[key].children);
      }

      dataService.setFloorHeight(
        dataService.currentFloor,
        this.layer.player.model.floors.index[dataService.currentFloor].center.y
      );
      for (let key in floor.symbols) {
        let symbol = symbolService.createSymbol(
          floor.symbols[key].startPoint,
          floor.symbols[key].endPoint,
          floor.symbols[key].geoType,
          floor.symbols[key].parent,
          floor.symbols[key].vectorId
        );
        symbol.openSide = floor.symbols[key].openSide;
        symbol.enter = floor.symbols[key].enter;
        symbol.points2d = JSON.parse(
          JSON.stringify(floor.symbols[key].points2d)
        );
      }

      for (let key in floor.components) {
        let component = componentService.createComponent(
          floor.components[key].center,
          floor.components[key].geoType,
          floor.components[key].vectorId
        );
        component.angle = floor.components[key].angle;
        //component.setPoints2d()
        component.sideThickness = floor.components[key].sideThickness;
        component.sideWidth = floor.components[key].sideWidth;
        component.points2d = JSON.parse(
          JSON.stringify(floor.components[key].points2d)
        );
      }

      if (floor.boundingBox) {
        dataService.setBoundingBox(floor.boundingBox, subgroup);
      } else {
        floor.boundingBox = mathUtil.getBoundingBox2(floor.points);
        dataService.setBoundingBox(floor.boundingBox, subgroup);
      }

      for (let key in floor.tags) {
        let tag = tagService.createTag(
          floor.tags[key].center,
          floor.tags[key].vectorId,
          subgroup
        );
        tag.setPoints2d();
        tag.setTitle(floor.tags[key].title);
        tag.setDes(floor.tags[key].des);
        tag.setUnit(floor.tags[key].unit);
        tag.setAdding(false);
      }

      for (let key in floor.furnitures) {
        let furniture = furnitureService.createFurniture(
          floor.furnitures[key].center,
          floor.furnitures[key].geoType,
          floor.furnitures[key].vectorId
        );
        furniture.angle = floor.furnitures[key].angle;
        if (floor.furnitures[key].scale) {
          furniture.zoom = floor.furnitures[key].scale;
        } else {
          furniture.zoom = floor.furnitures[key].zoom;
        }
      }

      if (floor.hasOwnProperty("name")) {
        dataService.setFloorName(floor.name, subgroup);
      }

      if (floor.hasOwnProperty("subgroup")) {
        dataService.setFloorSubgroup(floor.subgroup, subgroup);
      }

      if (floor.hasOwnProperty("id")) {
        dataService.setFloorId(floor.id, subgroup);
      }
    }
  }

  uploadCad() {
    this.initCameraService();
    this.uploadData.cadInfo = [];
    return this.exportCadImgs();
    // 开始上传：this.uploadData
    //this.uploadData = {}
  }

  initCameraService() {
    const modelSize = this.layer.app.core.get("Player").model.size;
    const currentScale = cameraService.getCurrentScale(modelSize);
    cameraService.setCamera(currentScale);
  }

  base64ToBlob(base64) {
    let arr = base64.split(","),
      mime = arr[0].match(/:(.*?);/)[1],
      bstr = atob(arr[1]),
      n = bstr.length,
      u8arr = new Uint8Array(n);
    while (n--) {
      u8arr[n] = bstr.charCodeAt(n);
    }
    return new Blob([u8arr], { type: mime });
  }

  exportImg(canvas) {
    // 图片导出为 png 格式
    var type = "png";
    var imgData = canvas.toDataURL(type, 3);
    let blobImg = this.base64ToBlob(imgData);
    return blobImg;
  }

  exportCadImgs() {
    this.layer.uiControl.menu_flex();
    tagService.clearDefaultTags();
    this.layer.history.save();
    stateService.clearItems();

    measureService.updateRegion(true);
    measureService.update();

    let canvas = this.layer.canvas;

    // coordinate.ratio = Constant.ratio
    // canvas.width = canvas.width * coordinate.ratio
    // canvas.height = canvas.height * coordinate.ratio

    canvas.width = Constant.cadImg_Width;
    canvas.height = Constant.cadImg_Height;
    coordinate.width = Constant.cadImg_Width / Constant.ratio;
    coordinate.height = Constant.cadImg_Height / Constant.ratio;

    coordinate.ratio = Constant.ratio;
    coordinate.res = Math.min(
      Constant.cadImg_Width /
        Constant.ratio /
        Math.abs(cameraService.right - cameraService.left),
      Constant.cadImg_Height /
        Constant.ratio /
        Math.abs(cameraService.top - cameraService.bottom)
    );

    this.layer.renderer.autoRedrawForImg();

    var deferred = window.KanKan.Deferred();

    setTimeout(() => {
      let subFloor = dataService.getFloorNum();
      this.uploadData.files = [];
      if (subFloor == 1) {
        let blobImg = this.exportImg(canvas);
        this.uploadData.files.push(blobImg);
        historyService.clearHistoryRecord();
        this.layer.$xui.toolbar.recall = false;
        this.layer.$xui.toolbar.recover = false;
      } else {
        let blobImg = this.exportImg(canvas);
        let currentFloor = dataService.getCurrentFloor();
        for (let i = 0; i < subFloor; ++i) {
          if (i == currentFloor) {
            this.uploadData.files.push(blobImg);
            continue;
          } else {
            this.layer.uiControl.currentFloor = i;
            this.layer.renderer.autoRedrawForImg();
            let _blobImg = this.exportImg(canvas);
            this.uploadData.files.push(_blobImg);
          }
        }
        this.layer.uiControl.currentFloor = currentFloor;
      }
      this.uploadData.cadInfo = dataService.getCadInfo(canvas);
      coordinate.updateForCanvas(canvas);
      coordinate.setRes(cameraService.left, cameraService.right);
      coordinate.ratio = 1;
      this.layer.renderer.autoRedraw();

      this.exportMiniMap(deferred);
    }, 100);

    return deferred;
  }

  exportMiniMap(deferred) {
    deferred = deferred || window.KanKan.Deferred();

    //this.layer.uiControl.menu_flex()
    stateService.clearItems();
    let canvas = this.layer.canvas;

    canvas.width = Constant.miniMap_Width;
    canvas.height = Constant.miniMap_Height;
    coordinate.width = Constant.miniMap_Width / Constant.ratio;
    coordinate.height = Constant.miniMap_Height / Constant.ratio;

    coordinate.ratio = Constant.ratio;
    coordinate.res = Math.min(
      Constant.miniMap_Width /
        Constant.ratio /
        Math.abs(cameraService.right - cameraService.left),
      Constant.miniMap_Height /
        Constant.ratio /
        Math.abs(cameraService.top - cameraService.bottom)
    );
    this.layer.renderer.redrawCore();

    setTimeout(() => {
      let subFloor = dataService.getFloorNum();
      this.uploadData.miniMaps = [];
      if (subFloor == 1) {
        let blobImg = this.exportImg(canvas);
        this.uploadData.miniMaps.push(blobImg);
      } else {
        let blobImg = this.exportImg(canvas);
        let currentFloor = dataService.getCurrentFloor();
        for (let i = 0; i < subFloor; ++i) {
          if (i == currentFloor) {
            this.uploadData.miniMaps.push(blobImg);
            continue;
          } else {
            this.layer.uiControl.currentFloor = i;
            let _blobImg = this.exportImg(canvas);
            this.layer.renderer.redrawCore();
            this.uploadData.miniMaps.push(_blobImg);
          }
        }
        this.layer.uiControl.currentFloor = currentFloor;
      }
      canvas.width = window.innerWidth;
      canvas.height = window.innerHeight;
      coordinate.updateForCanvas(canvas);

      let floorplanCamera =
        this.layer.app.core.get("CameraControls").activeControl.camera;
      coordinate.setRes(floorplanCamera.left, floorplanCamera.right);
      coordinate.ratio = 1;
      this.layer.renderer.autoRedraw();

      deferred.resolve(this.uploadData);
    }, 100);

    return deferred;
  }

  getCustomCadInfoItem(floorIndex, cadImg_Width, cadImg_Height) {
    //let cadImg_Width = Constant.cadImg_Width
    //let cadImg_Height = Constant.cadImg_Height

    // let cadImg_Width = 3840
    // let cadImg_Height = 2160

    function getScreenXY(point, res) {
      let pt = {
        x: point.x,
        y: point.y,
      };

      let x = cadImg_Width / 2 + (pt.x - coordinate.center.x) * res;
      let y = cadImg_Height / 2 - (pt.y - coordinate.center.y) * res;

      x = (0.5 + x) << 0;
      y = (0.5 + y) << 0;

      return {
        x: Math.floor(x),
        y: Math.floor(y),
      };
    }

    //let cadInfo = []
    let bounds = dataService.getAllBoundingBox(); //只是跟户型数据相关

    let res = Math.min(
      cadImg_Width / Math.abs(cameraService.right - cameraService.left),
      cadImg_Height / Math.abs(cameraService.top - cameraService.bottom)
    );

    //for (let i = 0; i < bounds.length; ++i) {
    let item = {};

    let leftTop = getScreenXY(
      {
        x: bounds[floorIndex].left,
        y: bounds[floorIndex].top,
      },
      res
    );

    let rightBottom = getScreenXY(
      {
        x: bounds[floorIndex].right,
        y: bounds[floorIndex].bottom,
      },
      res
    );

    let left = leftTop.x;
    let top = leftTop.y;

    let right = cadImg_Width - rightBottom.x;
    let bottom = cadImg_Height - rightBottom.y;

    item.left = left;
    item.top = top;
    item.right = right;
    item.bottom = bottom;

    item.bound = bounds[floorIndex];
    item.bound.top = -1 * item.bound.top;
    item.bound.bottom = -1 * item.bound.bottom;
    return item;
    //cadInfo.push(item)
    //}
    //return cadInfo   //和图片相关
  }

  //上传图片
  uploadCadImg(floorIndex, imgUrl, cadImg_Width, cadImg_Height) {
    //let floorIndex = 0;
    this.initCameraService();
    let cadInfoItem = this.getCustomCadInfoItem(
      floorIndex,
      cadImg_Width,
      cadImg_Height
    );
    //let cadInfos = this.getCustomCadInfoItem(3840,2160)     //上传图片的分辨率
    this.layer.app.core
      .get("Player")
      .model.floorplanCadImg.createCustomPlane(
        floorIndex,
        imgUrl,
        cadInfoItem,
        cadImg_Width,
        cadImg_Height
      );
  }

  //恢复图片
  recoverForCadImg(floorIndex, imgUrl) {
    this.layer.app.core
      .get("Player")
      .model.floorplanCadImg.updateCustomFloorTexture(floorIndex, imgUrl);
  }

  uploadCadImg2(floorIndex, imgUrl, cadImg_Width, cadImg_Height) {
    this.layer.app.core
      .get("Player")
      .model.floorplanCadImg.createCustomPlane(
        floorIndex,
        imgUrl,
        cadImg_Width,
        cadImg_Height
      );
  }
}