traffic-laser/src/sdk/types/sdk.ts

import { FloorType } from "./floorplan";
import { DataSetAtom, DownType } from "./dataset";
import { CoordType } from "./coord";
import { Emitter } from "mitt";
import { ColorMode, DensityType, Shape } from "./setting";
import { MeasureType, MeasureUnit } from "./measure";
import { Pos, Pos3D } from ".";
import { HotAtom } from "..";
import { UN_DE_RES } from "@/dbo/interfaces";
import { ModelModelAtom } from "./model";

/**
 * 参数说明
 * point 真实位置
 * screen 在DOM中的位置
 */
export type SceneEventMap = {
  buildingChange: ModelModelAtom;
  allLoaded: void;
  posChange: Pos3D & { dataset: string[]; meterPerPixel: number };
  loaded: void;
  webglError: void;
  visible: boolean;
  viewChange: "Top" | "Bottom" | string;
};

export type PointInfo = {
  position: Pos3D;
  datasetId: string;
  dataset_location: Pos3D;
};

// scene和map都要实现的基础
export type Base = Emitter<SceneEventMap> & {
  // 通过DOM坐标获取真实坐标
  getPointByScreen: (screen?: Pos & { inDrag?: boolean }) => PointInfo | null;
  // 通过真实坐标获取DOM坐标
  getScreenByPoint: (point: Pos, slide?: boolean) => { pos: Pos; trueSide: boolean };

  screenshot: (
    width: number,
    height: number
  ) => { finishPromise: Promise<{ dataUrl: string }>; meterPerPixel: number };
  el: HTMLElement;
};

export type Transform = {
  rotation: [number, number, number];
  position: [number, number, number];
};

export type ObjInfo = {
  objurl: string;
  mtlurl: string;
  transform: Transform;
};

export type Measure = {
  getPoints: () => Array<Pos3D>;
  getArea: () => { value: number; string: string };
  getDistance: () => { value: number; string: string };
  clear: () => void;
  show: () => void;
  hide: () => void;
  changeUnit: (unit: MeasureUnit) => void;
  toDataURL: (
    width: number,
    height: number
  ) => {
    dataUrl: string;
    pose: Pose;
  };
  bus: Emitter<{ update: Measure; selected: boolean; firstClickMarker: void }>;
  getDatasets: () => Array<string>;
  getDatasetId: () => string;
  getDatasetLocations: () => Array<Pos3D>;
  highlight: (isHight: boolean) => void;
  selected: (isHight: boolean) => void;
};

export type StartMeasure = Measure & {
  bus: Emitter<{ end: Measure; quit: Measure; invalidPoint: string }> & Measure["bus"];
  quit: () => void;
  end: () => void;
};

export type Crop = {
  bus: Emitter<{
    select: Array<DataSet>;
    updateSelectedDatasets: Array<DataSet["id"]>;
  }>;
  setSelect(datasets: Array<DataSet>): void;
  close(): void;
  toBlob(type: string, epsg?: string, name?: string): string;
};

export type DataSet = {
  setFloorPan(URL: string): void;
  getFloorPan(): string;
  gentDownURL(type: DownType): string;
  id: string;
  changeDisplay(show: boolean): void;
  changeColor(color: string): void;
  getAttachPloygon(): Ploygon;
  focus(): void;
  flyTo(): boolean;
};

export type NavigationResult = {
  time: number;
  dis: number;
  steps: Array<{
    desc: string;
    dis: number;
  }>;
};

export type Navigation = {
  setStartPoint(pos: PointInfo, inMap: boolean, datasetId?: string): void;
  setEndPoint(pos: PointInfo, inMap: boolean, datasetId?: string): void;
  generate(): Promise<NavigationResult | UN_DE_RES | string>;
  destroy(): void;
  bus: Emitter<{
    reposStartMarker: Pos3D;
    reposEndMarker: Pos3D;
  }>;
};

export type Pose = {
  position: Pos3D;
  yaw: number;
  pitch: number;
};

export type PoseVideoInfo = {
  position: Pos3D;
  target: Pos3D;
  time?: number;
};

export enum Mode {
  pano = 0,
  cloud = 1,
}

export type PloygonArgs = {
  flagPano: string;
  panos: number[];
  isNew: boolean;
  holes: Array<Pos[] | Pos3D[]>;
  points: Array<Pos3D | Pos>;
  parent: Ploygon | null;
  isUpdate: boolean;
  type: "building" | "floor" | "room";
  attach?: "top" | "bottom"; // floor特有
  zs: [number, number];
  // area: number
  // color: string
};

export type Ploygon = {
  changeHeight: (v: number) => number;
  digHole: () => void;
  getPano: () => { flagPano: string; panos: number[] };
  bus: Emitter<{ update: PloygonArgs; delete: void; complete: void }>;
  select: (isSelect: boolean) => void;
  reset: (PloygonArgs) => void;
  show: () => void;
  hide: () => void;
  delete: () => void;
  getArea: () => number;
  getVolume: () => number;
  getPoints: () => PloygonArgs;
  focus: () => number;
  isDelete: boolean;
};

export type FView = {
  //全屏漫游视图
  fullRoamView: () => void;
  // 全屏顶视图
  fullTopView: () => void;
  // 全屏右视图
  fullLeftSideView: () => void;
  // 全屏左视图
  fullRightSideView: () => void;
  // 退出全屏
  quitFull: () => void;

  enableTopMap: (enabled: boolean) => void;
  enableTopFloorPan: (enabled: boolean) => void;

  clear: () => void;

  focusOnDataset: (id: string) => void;
};

export type SiteMode = FView & {
  save: () => void;
  drawPloygon: (ploygon: PloygonArgs) => Ploygon;
};

export enum AlignmentTransform {
  "+x" = "+x",
  "-x" = "-x",
  "+y" = "+y",
  "-y" = "-y",
  "+z" = "+z",
  "-z" = "-z",
}
export enum AlignmentHandler {
  translate = "translate",
  rotate = "rotate",
}
export type AlignmentMode = FView & {
  translate: (str: AlignmentTransform) => void;
  rotate: (rotateNum: number) => void;
  switchHandle: (handler: AlignmentHandler) => void;
  selectDatasets: (datasets: Array<DataSet>) => void;
  save: () => Promise<void>;
  bus: Emitter<{ saveSuccess: void; moveInitialDataset: void; changed: void }>;
};

export type SiteModeInfoAtom =
  | (DataSetAtom & { type: "dataset" })
  | (Omit<PloygonArgs, "parent" | "isNew" | "attach"> & {
      children: Array<SiteModeInfoAtom>;
    });

export type SiteModeInfo = SiteModeInfoAtom[];
export type SceneCropSetting = {
  top: { value: number; maxTop: number; minTop: number };
  scale: { value: number };
  rotate: { value: number };
};
export type SeSceneCropSetting = {
  top?: { value: number };
  scale?: { value: number };
  rotate?: { value: number };
};

export type Scene = Base & {
  getDownloadInfo: () => any;
  currentCamera(): Pos3D;
  quitMeasure(): void;
  changeMode(mode: Mode): void;
  getCurrentMode(): Mode;
  startMeasure(type: MeasureType, unit: MeasureUnit, color: string): StartMeasure;
  drawMeasure(
    type: MeasureType,
    unit: MeasureUnit,
    points: ReturnType<Measure["getPoints"]>,
    datasetId: DataSetAtom["id"],
    datasetPoints: Array<Pos3D>,
    pointsDatasets: string[],
    sid: string,
    color: string
  ): Measure;
  trackScenePos: () => { promise: Promise<Pos3D>; quit: () => void };
  comeToMeasure: (measure: Measure) => Promise<void>;
  comeToTag: (pos: Pos3D) => Promise<void>;

  comeToHot: (hot: HotAtom) => Promise<void>;
  hotTransform: (pos: HotAtom) => Pos3D;

  // 漫游到指定位置
  comeTo: (pos: { position: Pos; target?: Pos; dur?: number }) => void;
  // 设置点云密度
  changePointDensity(type: DensityType): { percent: number };

  // 设置漫游点位显示
  changePanoPoint(show: boolean): void;
  // 设置色彩模式
  changeColorMode(mode: ColorMode): { opacity: number; size: number };
  // 设置范围
  changeViewRange(num: number): void;
  // 设置点透明度
  changePointOpacity(num: number): void;
  // 设置点大小
  changePointSize(num: number): void;
  // 设置点形状  传入参数 1 矩形 2 圆形
  changePointShape(shape: Shape): void;
  // 设置是否强化边缘
  changePointEdge(isStrong: boolean): void;
  changeDensityPercent(detail: number): void;

  // 打开裁剪模式
  openCropMode: () => Crop;

  // 查看是否支持全景图
  canTurnToPanoMode: (pos?: Pos3D) => boolean;

  canShapeToPanoMode: (poss?: Pos3D[]) => boolean;

  // 获取数据集
  getDataSets: () => Array<DataSet>;

  // 开启关闭放大镜
  openMagnifier: () => void;
  closeMagnifier: () => void;

  // 设置和获取当前位置信息
  getPose: () => Promise<Pose>;
  setPose: (pose: Pose) => void;

  getPose2: () => PoseVideoInfo;

  getSceneCropSetting: () => SceneCropSetting;
  setSceneCropSetting: (setting: SeSceneCropSetting) => void;
};

export type PoseVideo = {
  points: PoseVideoInfo[];
  duration: number;
  name?: string;
};
export type TourVideo = {
  bus: Emitter<{ changePoint: number; playComplete: void }>;
  addPoint: (
    index: number,
    pos: PoseVideoInfo["position"],
    target: PoseVideoInfo["target"]
  ) => void;
  deletePoint: (index: number) => void;
  play: () => void;
  pause: () => void;
  setDuration: (a: number) => void;
  clear: () => void;
};

export type ZoomInfo = { zoomLevel: number; meterPerPixel: number };
export type Map = Emitter<{ mapZoomLevelChange: ZoomInfo }> &
  Base & {
    getMapZoomLevel: () => ZoomInfo;
    setFloorplanEnable: (enable: boolean) => void;
    showDatasetFloor: (datasetId: DataSetAtom["id"]) => void;
    comeTo: (pos: { position: Pos; dur: number; zoom: number }) => void;
  };

export type LaserSDKProps = {
  sceneEl: Element;
  num: string;
  webSite: string;
  isDebug?: boolean;
  getFileUrl: (url: string) => Promise<string>;
  axios: any;
  basePath: string;
};

export enum TypeEmu {
  FIRE = "FIRE",
  BLAST = "BLAST",
  SMOKE = "SMOKE",
}

export type InsertEffectProp = {
  points: Pos3D[];
  radius?: number;
  height?: number;
  strength?: number;
  time?: number;
  color?: string;
};

export type Effect = {
  bus: Emitter<{ delete: void; update: InsertEffectProp; end: void }>;
  delete: () => void;
  switchEditState: (v: boolean) => void;
  hide: () => void;
  show: () => void;
  setRadius: (p: number) => void;
  setHeight: (p: number) => void;
  setStrength: (p: number) => void;
  setTime: (p: number) => void;
  setColor: (p: string) => void;
  fly: () => void;
};

export type Cloud = {
  uuid: string;
  pose: {
    rotation: Pos3D & { w: number };
    translation: Pos3D;
  };
  group: number;
  subgroup: number;
  visibles: number[];
};
export type EditCloudsArgs<T extends string = "clouds"> = ({
  [key in T]: Cloud[];
} & { datasetId: string })[];
export type ECloudsViewMode = "top" | "side" | "3d";
export type EditClouds = {
  bus: Emitter<{
    select: Cloud;
    cancelMove: void;
    cancelScale: void;
    needToDisConnect: void;
    cancelRotate: void;
    cancelConnect: void;
    cancelDisconnect: void;
    switchPanoVisible: [panosData: Cloud, visible: boolean];
  }>;
  changeShow(data: Cloud, show: boolean);
  changeRTK(data: Cloud, open: boolean);
  select: (data: Cloud) => void;
  moveMode: () => () => void;
  scaleMode: () => () => void;
  rotateMode: () => () => void;
  connectMode: () => void;
  disconnectMode: () => void;
  save: () => { sweepLocations: Cloud[] };
  calc: () => Promise<{ sweepLocations: Cloud[] } | string>;
  switchViewMode: (mode: ECloudsViewMode) => void;
};

export type ECropArgs = {};
export type ECropViewMode = "top" | "3d";
export type CropShape = {
  delete: () => void;
};
export type EditCrop = {
  // 你发送我
  bus: Emitter<{
    // 取消移动模式
    cancelMove: void;
    // 取消放大缩小模式
    cancelScale: void;
    // 取消旋转模式
    cancelRotate: void;
    // 取消排除模式
    cancelExclude: void;
    // 取消交集模式
    cancelIntersect: void;
    // 选择裁剪形状
    selectShape: CropShape;
    // 取消选择裁剪形状
    unSelectShape: void;
  }>;
  // 进入移动模式 返回取消移动函数
  moveMode: () => () => void;
  // 进入放大模式 返回取消放大函数
  scaleMode: () => () => void;
  // 进入旋转模式 返回取消旋转函数
  rotateMode: () => () => void;
  // 进入排除模式 返回取消排除函数
  excludeMode: () => void;
  // 进入交集模式 返回取消交集函数
  intersectMode: () => void;
  // 保存时调用  返回要发送给服务端的参数
  save: () => ECropArgs;
  // 计算时调用  返回要发送给服务端的参数 或者是报错的字符串
  calc: () => Promise<ECropArgs | string>;
  // 切换视图 参数为 'top' | '3d'
  switchViewMode: (mode: ECropViewMode) => void;
  // 清除所有
  clearAll: () => void;
};

export type LaserSDK = {
  map: Map;
  scene: Scene;
  enterDatasetsManage: () => any;
  enterTopView: () => any;
  leaveTopView: () => any;
  leaveDatasetsManage: () => any;
  getPointByEntity: (id: string) => Pos3D;
  entityIncludePoint: (id: string, pos: Pos3D) => boolean;
  gotoEntity: (
    id: string,
    isNearBy: boolean
  ) => boolean | "posNoChange" | "tooFar" | "deferred";
  focusEntity: (id: string) => void;
  openSplitScreen: () => void;
  setSplitScreenSize: (size: number) => void;
  setSplitScreenDir: (dir: "leftRight" | "upDown") => void;
  closeSplitScreen: () => void;
  setFloorplanType: (type: FloorType, datasetid: DataSetAtom["id"]) => void;

  // 地图全屏显示
  mapFullShow(): void;
  // 地图全屏显示
  sceneFullShow(): void;

  minimumShow(): void;
  minimumHide(): void;

  getEntityByPoint: (pos: Pos3D) => ModelModelAtom;

  // 设置地图可视
  changeScene(show: boolean): void;
  // 是否禁用平面图
  setFloorplanEnable: (Enable: boolean) => void;

  // 创建导航对象
  createNavigation: () => Navigation;

  // 坐标转换
  coordTransform: <T extends CoordType, K extends CoordType>(
    originType: T,
    pos: T extends CoordType.SCENE_SCREEN | CoordType.MAP_SCREEN ? Pos : Pos3D,
    targetType: K,
    datasetId?: string,
    originHandler?: boolean
  ) => Pos | Pos3D;

  enterSiteMode: () => SiteMode;

  enterAlignment: () => AlignmentMode;
  enterEditClouds: (data: EditCloudsArgs) => EditClouds;
  enterEditCrop: () => EditCrop;

  transformPoint: (point: Pos3D, datasetId: string, dataset_location: Pos3D) => Pos3D;

  enterMeasurement: () => void;
  leaveMeasurement: () => void;

  refreshFloorPan: () => void;
  reloadDatasets: () => void;
  setMapEnable: (enable: boolean) => void;
  setSiteModelInfo(tree: SiteModeInfo): void;
  enterGeoRegistration(): void;
  leaveGeoRegistration(): void;

  enterTourEdit: (data: PoseVideo) => TourVideo;

  enterFireEdit: () => void;

  insertEffect: (type: TypeEmu, prop: InsertEffectProp, edit: boolean) => Effect;

  debug: boolean;
  // 加载小物体
  loadObj: (info: ObjInfo) => Promise<void>;
  loadModel: (info: ObjInfo) => Promise<void>;
};