traffic-laser/src/graphic/Service/PointService.js

import Point from "../Geometry/Point.js";
import Line from "../Geometry/Line.js";
import { dataService } from "./DataService.js";
import VectorCategory from "../enum/VectorCategory.js";
import { mathUtil } from "../Util/MathUtil.js";
import { lineService } from "./LineService.js";
import Settings from "../Settings.js";
export default class PointService {
  constructor() {}

  create(position, vectorId) {
    let point = new Point(position, vectorId);
    dataService.addPoint(point);
    this.updateBasePointIds()
    return point;
  }

  //将pointId1合并到pointId2
  mergePoint(pointId1, pointId2) {
    if (pointId1 == pointId2) {
      return;
    } else if (pointId1 != null && pointId2 != null) {
      let point1 = dataService.getPoint(pointId1);
      let parent1 = point1.getParent();
      let point2 = dataService.getPoint(pointId2);
      if (mathUtil.equalPoint(point1, point2)) {
        let lineId = lineService.getLine(pointId1, pointId2);
        if (lineId) {
          dataService.deleteLine(lineId);
          return;
        }
      }
      for (let key in parent1) {
        let line = dataService.getLine(key);
        let dir = line.getDir(pointId1);
        if (dir == "start") {
          line.startId = pointId2;
        } else if (dir == "end") {
          line.endId = pointId2;
        }
        point2.setPointParent(key, dir);
      }
      dataService.deletePoint(pointId1);
    }
  }

  deletePoint(pointId) {
    let point = dataService.getPoint(pointId);
    if (point) {
      const category = point.getCategory();
      if (category == VectorCategory.Point.NormalPoint) {
        dataService.deletePoint(pointId); //暂时简单粗暴
      } else if (category == VectorCategory.Point.BasePoint) {
        this.deleteBasePoint(pointId);
      } else if (
        category == VectorCategory.Point.TestPoint ||
        category == VectorCategory.Point.TestBasePoint
      ) {
        this.deleteTestPoint(pointId);
      }
    }
  }
  updateBasePointIds() {
    let points = dataService.vectorData.points;
    Settings.basePointIds = [];
    for (let key in points) {
      if (points[key].category == VectorCategory.Point.BasePoint) {
        Settings.basePointIds.push(points[key].vectorId);
      }
    }
  }
  deleteBasePoint(basePointId) {
    let points = dataService.getPoints();
    let needDeletePointIds = [];
    for (let key in points) {
      let point = dataService.getPoint(key);
      if (point.vectorId == basePointId) {
        needDeletePointIds.push(basePointId);
      } else if (point.linkedBasePointId == basePointId) {
        needDeletePointIds.push(key);
      }
    }
    let lines = dataService.getLines();
    for (let key in lines) {
      let line = dataService.getLine(key);
      if (
        needDeletePointIds.indexOf(line.startId) > -1 ||
        needDeletePointIds.indexOf(line.endId) > -1
      ) {
        dataService.deleteLine(key);
      }
    }
    dataService.deletePoint(basePointId);
    if (Settings.selectBasePointId == basePointId) {
      Settings.selectBasePointId = null;
    }
    this.updateBasePointIds()
  }

  deleteTestPoint(testPointId) {
    let points = dataService.getPoints();
    let needDeletePointIds = [];
    for (let key in points) {
    
      let point = dataService.getPoint(key);
      if(point.getCategory() == VectorCategory.Point.BasePoint){
        continue
      }
      if (point.vectorId == testPointId) {
        needDeletePointIds.push(testPointId);
      } else if (point.linkedTestPointId == testPointId) {
        needDeletePointIds.push(key);
      }
    }
    let lines = dataService.getLines();
    for (let key in lines) {
      let line = dataService.getLine(key);
      let startPoint = dataService.getPoint(line.startId);
      let endPoint = dataService.getPoint(line.endId);
      if (
        needDeletePointIds.indexOf(line.startId) > -1 ||
        needDeletePointIds.indexOf(line.endId) > -1
      ) {
        dataService.deleteLine(key);
        if (needDeletePointIds.indexOf(line.startId) > -1&& endPoint.getCategory()!= VectorCategory.Point.BasePoint) {
          this.deleteTestPoint(line.endId);
        }
        if (needDeletePointIds.indexOf(line.endId) > -1 && startPoint.getCategory()!= VectorCategory.Point.BasePoint) {
          this.deleteTestPoint(line.startId);
        }
      }
    }
    dataService.deletePoint(testPointId);
  }


}

const pointService = new PointService();
export { pointService };