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);

      //可能会有重复的线段
      let parent2 = point2.getParent();
      let keys = Object.keys(parent2);
      for (let i = 0; i < keys.length - 1; ++i) {
        for (let j = i + 1; j < keys.length; ++j) {
          let line1 = dataService.getLine(keys[i]);
          let line2 = dataService.getLine(keys[j]);
          if (
            (line1.startId == line2.startId && line1.endId == line2.endId) ||
            (line1.endId == line2.startId && line1.startId == line2.endId)
          ) {
            dataService.deleteLine(line1.vectorId);
            return;
          }
        }
      }
    }
  }

  deletePoint(pointId) {
    let point = dataService.getPoint(pointId);
    if (point) {
      const category = point.getCategory();
      if (category == VectorCategory.Point.NormalPoint) {
        this.deleteNormalPoint(pointId); //暂时简单粗暴
      } else if (category == VectorCategory.Point.BasePoint) {
        this.deleteBasePoint(pointId);
      } else if (category == VectorCategory.Point.TestBasePoint) {
        this.deleteTestPoint(pointId);
      } else if (category == VectorCategory.Point.FixPoint) {
        this.deleteFixPoint(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);
      }
    }
  }

  deleteNormalPoint(normalPointId) {
    let normalPoint = dataService.getPoint(normalPointId);
    let parent = normalPoint.getParent();
    for (let key in parent) {
      dataService.deleteLine(key);
    }
  }

  deleteBasePoint(basePointId) {
    let lines = dataService.getLines();
    for (let key in lines) {
      let line = dataService.getLine(key);
      if (line.getLinkedBasePointId() == basePointId) {
        dataService.deleteLine(key);
      }
    }
    dataService.deletePoint(basePointId);
  }

  deleteFixPoint(fixPointId) {
    let lines = dataService.getLines();
    for (let key in lines) {
      let line = dataService.getLine(key);
      if (line.getLinkedFixPointId() == fixPointId) {
        dataService.deleteLine(key);
      }
    }
    let fixPoint = dataService.getPoint(fixPointId);
    let textId = fixPoint.linkedTextId;
    dataService.deletePoint(fixPointId);
    dataService.deleteText(textId);
  }

  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);
      }
    }
    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 };