traffic-laser/src/graphic/ListenLayer.js

import { mathUtil } from "./Util/MathUtil";
import { dataService } from "./Service/DataService.js";
import { stateService } from "./Service/StateService.js";
import { roadService } from "./Service/RoadService.js";
import Constant from "./Constant.js";
import VectorType from "./enum/VectorType.js";
import SelectState from "./enum/SelectState.js";

export default class ListenLayer {
  constructor() {
    this.roadInfo = {
      roadId: null,
      state: null, // 未选中null
    };

    this.pointInfo = {
      pointId: null,
      state: null,
    };

    this.tagInfo = {
      tagId: null,
      state: null,
    };

    this.modifyPoint = null;
  }

  //开始监听，exceptPointId表示不考虑的点，exceptRoadIds表示不考虑的墙
  start(position, exceptPointId, exceptRoadIds) {
    let nearest = this.getNearForVectors(
      position,
      exceptPointId,
      exceptRoadIds
    );

    if (
      nearest.modifyPoint &&
      (nearest.modifyPoint.hasOwnProperty("linkedPointId") ||
        nearest.modifyPoint.hasOwnProperty("linkedPointIdX") ||
        nearest.modifyPoint.hasOwnProperty("linkedPointIdY") ||
        nearest.modifyPoint.hasOwnProperty("linkedRoadId"))
    ) {
      this.modifyPoint = {
        x: nearest.modifyPoint.x,
        y: nearest.modifyPoint.y,
      };
      if (
        nearest.modifyPoint.hasOwnProperty("linkedPointId") &&
        nearest.modifyPoint.linkedPointId != null
      ) {
        this.modifyPoint.linkedPointId = nearest.modifyPoint.linkedPointId;
      } else if (
        nearest.modifyPoint.hasOwnProperty("linkedRoadId") &&
        nearest.modifyPoint.linkedRoadId != null
      ) {
        this.modifyPoint.linkedRoadId = nearest.modifyPoint.linkedRoadId;
      } else {
        if (
          nearest.modifyPoint.hasOwnProperty("linkedPointIdX") &&
          nearest.modifyPoint.linkedPointIdX != null
        ) {
          this.modifyPoint.linkedPointIdX = nearest.modifyPoint.linkedPointIdX;
        }
        if (
          nearest.modifyPoint.hasOwnProperty("linkedPointIdY") &&
          nearest.modifyPoint.linkedPointIdY != null
        ) {
          this.modifyPoint.linkedPointIdY = nearest.modifyPoint.linkedPointIdY;
        }
      }
    } else {
      this.modifyPoint = null;
    }

    const flag = this.updateSelectInfos(nearest, Constant.minAdsorbPix);
    this.updateSelectItem();
    return flag;
  }

  // 获得最近的墙面和墙角
  // 同时获得吸附的相关信息
  // 找到选中的symbol(只有选中了，才算是最近的)
  getNearForVectors(position, exceptPointId, exceptRoadIds) {
    let min1 = null; // 与墙角的距离
    let min2 = null; // 与墙面的距离
    // 纠正
    // 垂直，水平
    const modifyPoint = {};
    // 吸附在墙面上
    let _modifyPoint = null;
    const hasPointIds = [];
    if (exceptPointId) {
      hasPointIds.push(exceptPointId);
    }

    const roads = dataService.getRoads();
    for (const roadId in roads) {
      if (exceptRoadIds && exceptRoadIds.hasOwnProperty(roadId)) {
        continue;
      }

      const road = dataService.getRoad(roadId);

      const startPoint = dataService.getPoint(road.startId);
      const endPoint = dataService.getPoint(road.endId);
      let distance = null;
      const line = roadService.getMidLine(road);
      if (!line) {
        //debugger
        //删除墙
        dataService.deleteRoad(roadId);
        continue;
        console.error("getNearForVectors************************************");
      }
      const join = mathUtil.getJoinLinePoint(position, line);

      //先找端点
      if (hasPointIds.indexOf(road.startId) == -1) {
        hasPointIds.push(road.startId);
        distance = mathUtil.getDistance(position, startPoint);

        if (min1 == null || min1.distance > distance) {
          min1 = {
            distance: distance,
            pointId: road.startId,
          };

          //start部分找到了墙的端点
          if (
            (mathUtil.getDistance(join, position) < road.width / 2 &&
              mathUtil.getDistance(join, startPoint) < road.width / 2) ||
            min1.distance < road.width / 2
          ) {
            modifyPoint.linkedPointId = road.startId;
            modifyPoint.x = startPoint.x;
            modifyPoint.y = startPoint.y;

            delete modifyPoint.linkedPointIdX;
            delete modifyPoint.linkedPointIdY;
            break;
          }
        }
        // //start部分找到了与x接近的其他点
        // if (Math.abs(position.x - startPoint.x) < Constant.minAdsorbPix) {
        //   if (!modifyPoint.linkedPointIdX) {
        //     modifyPoint.x = startPoint.x;
        //     modifyPoint.linkedPointIdX = road.startId;
        //   } else {
        //     const linkedPointX = dataService.getPoint(
        //       modifyPoint.linkedPointIdX
        //     );
        //     if (
        //       mathUtil.getDistance(position, linkedPointX) >
        //       mathUtil.getDistance(position, startPoint)
        //     ) {
        //       modifyPoint.x = startPoint.x;
        //       modifyPoint.linkedPointIdX = road.startId;
        //     }
        //   }
        // }
        // //start部分找到了与y接近的其他点
        // if (Math.abs(position.y - startPoint.y) < Constant.minAdsorbPix) {
        //   if (!modifyPoint.linkedPointIdY) {
        //     modifyPoint.y = startPoint.y;
        //     modifyPoint.linkedPointIdY = road.startId;
        //   } else {
        //     const linkedPointY = dataService.getPoint(
        //       modifyPoint.linkedPointIdY
        //     );
        //     if (
        //       mathUtil.getDistance(position, linkedPointY) >
        //       mathUtil.getDistance(position, startPoint)
        //     ) {
        //       modifyPoint.y = startPoint.y;
        //       modifyPoint.linkedPointIdY = road.startId;
        //     }
        //   }
        // }
      }

      if (hasPointIds.indexOf(road.endId) == -1) {
        hasPointIds.push(road.endId);
        distance = mathUtil.getDistance(position, endPoint);

        if (min1 == null || min1.distance > distance) {
          min1 = {
            distance: distance,
            pointId: road.endId,
          };
          //end部分找到了墙的端点
          if (
            (mathUtil.getDistance(join, position) < road.width / 2 &&
              mathUtil.getDistance(join, endPoint) < road.width / 2) ||
            min1.distance < road.width / 2
          ) {
            modifyPoint.linkedPointId = road.endId;
            modifyPoint.x = endPoint.x;
            modifyPoint.y = endPoint.y;
            delete modifyPoint.linkedPointIdX;
            delete modifyPoint.linkedPointIdY;
            break;
          }
        }
        // //end部分找到了与x接近的其他点
        // if (Math.abs(position.x - endPoint.x) < Constant.minAdsorbPix) {
        //   if (!modifyPoint.linkedPointIdX) {
        //     modifyPoint.x = endPoint.x;
        //     modifyPoint.linkedPointIdX = road.endId;
        //   } else {
        //     const linkedPointX = dataService.getPoint(
        //       modifyPoint.linkedPointIdX
        //     );
        //     if (
        //       mathUtil.getDistance(position, linkedPointX) >
        //       mathUtil.getDistance(position, endPoint)
        //     ) {
        //       modifyPoint.x = endPoint.x;
        //       modifyPoint.linkedPointIdX = road.endId;
        //     }
        //   }
        // }
        // //end部分找到了与y接近的其他点
        // if (Math.abs(position.y - endPoint.y) < Constant.minAdsorbPix) {
        //   if (!modifyPoint.linkedPointIdY) {
        //     modifyPoint.y = endPoint.y;
        //     modifyPoint.linkedPointIdY = road.endId;
        //   } else {
        //     const linkedPointY = dataService.getPoint(
        //       modifyPoint.linkedPointIdY
        //     );
        //     if (
        //       mathUtil.getDistance(position, linkedPointY) >
        //       mathUtil.getDistance(position, endPoint)
        //     ) {
        //       modifyPoint.y = endPoint.y;
        //       modifyPoint.linkedPointIdY = road.endId;
        //     }
        //   }
        // }
      }

      distance = mathUtil.getDistance(position, join);
      //是否在墙上，可能在墙外
      const _flag = roadService.isContain(road, join);

      if (_flag && (min2 == null || min2.distance > distance)) {
        min2 = {
          distance: distance,
          roadId: roadId,
        };
      }

      if (_flag && mathUtil.getDistance(position, join) < road.width / 2) {
        _modifyPoint = join;
        _modifyPoint.linkedRoadId = roadId;
      }
    }
    const result = {
      minPoint: min1,
      minRoad: min2,
      tagInfo: {},
    };

    if (_modifyPoint != null) {
      result.modifyPoint = JSON.parse(JSON.stringify(_modifyPoint));
    } else if (
      modifyPoint.hasOwnProperty("x") &&
      modifyPoint.hasOwnProperty("y")
    ) {
      result.modifyPoint = JSON.parse(JSON.stringify(modifyPoint));
    } else if (modifyPoint.hasOwnProperty("x")) {
      result.modifyPoint = JSON.parse(JSON.stringify(modifyPoint));
      result.modifyPoint.x = modifyPoint.x;
      result.modifyPoint.y = position.y;
    } else if (modifyPoint.hasOwnProperty("y")) {
      result.modifyPoint = JSON.parse(JSON.stringify(modifyPoint));
      result.modifyPoint.x = position.x;
      result.modifyPoint.y = modifyPoint.y;
    }

    // const tags = dataService.getTags();
    // for (const tagId in tags) {
    //   const tag = dataService.getTag(tagId);
    //   const location = tag.isContain(position);
    //   if (location) {
    //     result.tagInfo = {
    //       tagId: tagId,
    //       state: "all",
    //     };
    //     break;
    //   }
    // }
    return result;
  }

  // position用来判断是否在墙的symbol上
  updateSelectInfos(nearest, minDistance) {
    // 墙角状态是否改变
    let flag1 = false;
    if (nearest.minPoint != null) {
      if (nearest.minPoint.distance < minDistance) {
        flag1 = this.isChanged(nearest.minPoint.pointId, SelectState.Select, 1);
        this.pointInfo = {
          pointId: nearest.minPoint.pointId,
          state: SelectState.Select,
        };
      } else {
        flag1 = this.isChanged(nearest.minPoint.pointId, null, 1);
        this.pointInfo = {
          pointId: nearest.minPoint.pointId,
          state: null,
        };
      }
    } else {
      flag1 = this.isChanged(null, null, 1);
      this.pointInfo = {
        pointId: null,
        state: null,
      };
    }
    // 墙面状态是否改变
    let flag2 = false;
    if (nearest.minRoad != null) {
      if (nearest.minRoad.distance < minDistance) {
        flag2 = this.isChanged(nearest.minRoad.roadId, SelectState.Select, 2);
        this.roadInfo = {
          roadId: nearest.minRoad.roadId,
          state: SelectState.Select,
        };
      } else {
        flag2 = this.isChanged(nearest.minRoad.roadId, null, 2);
        this.roadInfo = {
          roadId: nearest.minRoad.roadId,
          state: null,
        };
      }
    } else {
      flag2 = this.isChanged(null, null, 2);
      this.roadInfo = {
        roadId: null,
        state: null,
      };
    }

    const flag5 = this.isChanged(
      nearest.tagInfo.tagId,
      nearest.tagInfo.state,
      5
    );
    this.tagInfo = {
      tagId: nearest.tagInfo.tagId,
      state: nearest.tagInfo.state,
    };

    return flag1 || flag2 || flag5;
  }

  // type是1表示点，2表示墙，3表示symbol，4表示component, 5表示tag，6表示furniture
  isChanged(vectorId, state, type) {
    let flag = false;
    if (type == 1) {
      if (state == null && state == this.pointInfo.state) {
        flag = false;
      } else if (
        this.pointInfo.pointId == vectorId &&
        state == this.pointInfo.state
      ) {
        flag = false;
      } else {
        flag = true;
      }
    } else if (type == 2) {
      if (state == null && state == this.roadInfo.state) {
        flag = false;
      } else if (
        this.roadInfo.roadId == vectorId &&
        state == this.roadInfo.state
      ) {
        flag = false;
      } else {
        flag = true;
      }
    } else if (type == 5) {
      if (state == null && state == this.tagInfo.state) {
        flag = false;
      } else if (
        this.tagInfo.tagId == vectorId &&
        state == this.tagInfo.state
      ) {
        flag = false;
      } else {
        flag = true;
      }
    }
    return flag;
  }

  updateSelectItem() {
    if (this.tagInfo.tagId != null && this.tagInfo.state != null) {
      const tag = dataService.getTag(this.tagInfo.tagId);
      stateService.setSelectItem(
        this.tagInfo.tagId,
        tag.geoType,
        this.tagInfo.state
      );
    } else if (this.pointInfo.pointId != null && this.pointInfo.state != null) {
      stateService.setSelectItem(
        this.pointInfo.pointId,
        VectorType.RoadCorner,
        SelectState.Select
      );
    } else if (this.roadInfo.roadId != null && this.roadInfo.state != null) {
      stateService.setSelectItem(
        this.roadInfo.roadId,
        VectorType.Road,
        SelectState.Select
      );
    } else {
      stateService.clearSelectItem();
    }
  }

  clear() {
    this.roadInfo = {
      roadId: null,
      state: null,
    };

    this.pointInfo = {
      pointId: null,
      state: null,
    };

    this.modifyPoint = null;
  }
}
const listenLayer = new ListenLayer();
export { listenLayer };