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

import RoadPoint from "../Geometry/RoadPoint.js";
import Road from "../Geometry/Road.js";
import CurveRoad from "../Geometry/CurveRoad.js";
import { dataService } from "./DataService.js";
import { roadPointService } from "./RoadPointService.js";
import { edgeService } from "./EdgeService.js";
import { mathUtil } from "../Util/MathUtil.js";
import Constant from "../Constant";
import { crossPointService } from "./CrossPointService.js";
import { lineService } from "./LineService.js";
import { uiService } from "./UIService.js";
import VectorStyle from "../enum/VectorStyle.js";

export default class RoadService {
  constructor() {}

  create(startId, endId, vectorId) {
    let road = new Road(startId, endId, vectorId);
    dataService.addRoad(road);

    let startPoint = dataService.getRoadPoint(startId);
    startPoint.setPointParent(road.vectorId, "start");

    let endPoint = dataService.getRoadPoint(endId);
    endPoint.setPointParent(road.vectorId, "end");

    let edgePoints;
    if (road.way == Constant.oneWay) {
      edgePoints = mathUtil.RectangleVertex(
        startPoint,
        endPoint,
        road.singleRoadWidth
      );
    } else {
      edgePoints = mathUtil.RectangleVertex(
        startPoint,
        endPoint,
        road.leftWidth + road.rightWidth + road.midDivide.midDivideWidth
      );
    }
    let leftEdge = edgeService.create(
      edgePoints.leftEdgeStart,
      edgePoints.leftEdgeEnd,
      null,
      vectorId
    );

    let rightEdge = edgeService.create(
      edgePoints.rightEdgeStart,
      edgePoints.rightEdgeEnd,
      null,
      vectorId
    );

    road.setLeftEdge(leftEdge.vectorId);
    road.setRightEdge(rightEdge.vectorId);
    if (!vectorId) {
      leftEdge.setEdgeParent(road.vectorId);
      rightEdge.setEdgeParent(road.vectorId);
    }
    this.setLanes(road.vectorId);
    return road;
  }

  //撤销恢复用的，edge这些会专门调用
  createOnlyRoad(startId, endId, vectorId) {
    let road = new Road(startId, endId, vectorId);
    dataService.addRoad(road);

    let startPoint = dataService.getRoadPoint(startId);
    startPoint.setPointParent(road.vectorId, "start");

    let endPoint = dataService.getRoadPoint(endId);
    endPoint.setPointParent(road.vectorId, "end");
    return road;
  }

  copyRoad(vectorId) {
    let road = dataService.getRoad(vectorId);
    let startPoint = dataService.getRoadPoint(road.startId);
    let endPoint = dataService.getRoadPoint(road.endId);

    let newStartPoint = uiService.getNewPositionForPop(startPoint);
    newStartPoint = roadPointService.create(newStartPoint);
    let newEndPoint = uiService.getNewPositionForPop(endPoint);
    newEndPoint = roadPointService.create(newEndPoint);

    let newRoad = new Road(newStartPoint.vectorId, newEndPoint.vectorId);
    dataService.addRoad(newRoad);

    newStartPoint.setPointParent(newRoad.vectorId, "start");
    newEndPoint.setPointParent(newRoad.vectorId, "end");

    newRoad.setWay(road.way);
    newRoad.singleRoadWidth = road.singleRoadWidth;
    newRoad.leftWidth = road.leftWidth;
    newRoad.rightWidth = road.rightWidth;

    let edgePoints;
    if (newRoad.way == Constant.oneWay) {
      edgePoints = mathUtil.RectangleVertex(
        newStartPoint,
        newEndPoint,
        road.singleRoadWidth
      );
    } else {
      edgePoints = mathUtil.RectangleVertex(
        newStartPoint,
        newEndPoint,
        road.leftWidth + road.rightWidth + road.midDivide.midDivideWidth
      );
    }
    let leftEdge = edgeService.create(
      edgePoints.leftEdgeStart,
      edgePoints.leftEdgeEnd,
      null,
      vectorId
    );

    let rightEdge = edgeService.create(
      edgePoints.rightEdgeStart,
      edgePoints.rightEdgeEnd,
      null,
      vectorId
    );

    newRoad.setLeftEdge(leftEdge.vectorId);
    newRoad.setRightEdge(rightEdge.vectorId);
    if (!vectorId) {
      leftEdge.setEdgeParent(newRoad.vectorId);
      rightEdge.setEdgeParent(newRoad.vectorId);
    }

    let oldLeftEdge = dataService.getRoadEdge(road.leftEdgeId);
    leftEdge.start = uiService.getNewPositionForPop(oldLeftEdge.start);
    leftEdge.end = uiService.getNewPositionForPop(oldLeftEdge.end);
    leftEdge.setParent(newRoad.vectorId);
    leftEdge.setStyle(oldLeftEdge.getStyle());
    leftEdge.setWeight(oldLeftEdge.getWeight());

    let oldRightEdge = dataService.getRoadEdge(road.rightEdgeId);
    rightEdge.start = uiService.getNewPositionForPop(oldRightEdge.start);
    rightEdge.end = uiService.getNewPositionForPop(oldRightEdge.end);
    rightEdge.setParent(newRoad.vectorId);
    rightEdge.setStyle(oldRightEdge.getStyle());
    rightEdge.setWeight(oldRightEdge.getWeight());

    newRoad.singleRoadDrivewayCount = road.singleRoadDrivewayCount;
    newRoad.leftDrivewayCount = road.leftDrivewayCount;
    newRoad.rightDrivewayCount = road.rightDrivewayCount;
    this.setLanes(newRoad.vectorId);
    return newRoad.vectorId;
  }

  getMidLine(road) {
    let startPoint = dataService.getRoadPoint(road.startId);
    let endPoint = dataService.getRoadPoint(road.endId);
    let line = mathUtil.createLine1(startPoint, endPoint);
    return line;
  }

  // roadId对应墙的两个端点。尽量不要改
  // dir表示:保留start还是保留end(对应端点的parent不用变)
  splitRoad(roadId, pointId, dir) {
    const road = dataService.getRoad(roadId);
    const startPoint = dataService.getRoadPoint(road.startId);
    const endPoint = dataService.getRoadPoint(road.endId);
    const point = dataService.getRoadPoint(pointId);
    if (
      mathUtil.getDistance(startPoint, point) < Constant.minAdsorbPix ||
      mathUtil.getDistance(endPoint, point) < Constant.minAdsorbPix
    ) {
    }

    let leftEdge = dataService.getRoadEdge(road.leftEdgeId);
    let rightEdge = dataService.getRoadEdge(road.rightEdgeId);

    let oldLeftEdgeStartPoint = {
      x: leftEdge.start.x,
      y: leftEdge.start.y,
    };
    let oldLeftEdgeEndPoint = {
      x: leftEdge.end.x,
      y: leftEdge.end.y,
    };

    let oldRightEdgeStartPoint = {
      x: rightEdge.start.x,
      y: rightEdge.start.y,
    };
    let oldRightEdgeEndPoint = {
      x: rightEdge.end.x,
      y: rightEdge.end.y,
    };

    let newRoad = null;
    if (dir == "start") {
      // 第一步把旧的road的另一端点对应的parent(旧的roadId)断开
      delete endPoint.parent[roadId];
      newRoad = this.create(pointId, road.endId);
      // 更新旧公路的end
      point.setPointParent(roadId, "end");
      road.endId = pointId;
    } else if (dir == "end") {
      delete startPoint.parent[roadId];
      newRoad = this.create(road.startId, pointId);
      //修改旧公路的start
      point.setPointParent(roadId, "start");
      road.startId = pointId;
    }

    if (road.way == Constant.oneWay) {
      newRoad.setWay(road.way);
      newRoad.singleRoadDrivewayCount = road.singleRoadDrivewayCount;
    } else if (road.way == Constant.twoWay) {
      newRoad.setWay(road.way);
      newRoad.leftDrivewayCount = road.leftDrivewayCount;
      newRoad.rightDrivewayCount = road.rightDrivewayCount;
    }

    // 更新断开后两个road之间的edge
    edgeService.updateEdgeForTwoRoad(roadId, newRoad.vectorId);

    // 需要更新crossPoints
    if (dir == "start") {
      let cpt = dataService.getCrossPointForEdgeId(road.leftEdgeId, "end");
      crossPointService.replaceEdgeId(cpt, road.leftEdgeId, newRoad.leftEdgeId);

      cpt = dataService.getCrossPointForEdgeId(road.rightEdgeId, "end");
      crossPointService.replaceEdgeId(
        cpt,
        road.rightEdgeId,
        newRoad.rightEdgeId
      );

      let newRoadLeftEdge = dataService.getRoadEdge(newRoad.leftEdgeId);
      mathUtil.clonePoint(newRoadLeftEdge.end, oldLeftEdgeEndPoint);

      let newRoadRightEdge = dataService.getRoadEdge(newRoad.rightEdgeId);
      mathUtil.clonePoint(newRoadRightEdge.end, oldRightEdgeEndPoint);

      if (Object.keys(startPoint).length > 1) {
        mathUtil.clonePoint(leftEdge.start, oldLeftEdgeStartPoint);
        mathUtil.clonePoint(rightEdge.start, oldRightEdgeStartPoint);
      }
    } else if (dir == "end") {
      let cpt = dataService.getCrossPointForEdgeId(road.leftEdgeId, "start");
      crossPointService.replaceEdgeId(cpt, road.leftEdgeId, newRoad.leftEdgeId);

      cpt = dataService.getCrossPointForEdgeId(road.rightEdgeId, "start");
      crossPointService.replaceEdgeId(
        cpt,
        road.rightEdgeId,
        newRoad.rightEdgeId
      );

      let newRoadLeftEdge = dataService.getRoadEdge(newRoad.leftEdgeId);
      mathUtil.clonePoint(newRoadLeftEdge.start, oldLeftEdgeStartPoint);

      let newRoadRightEdge = dataService.getRoadEdge(newRoad.rightEdgeId);
      mathUtil.clonePoint(newRoadRightEdge.start, oldRightEdgeStartPoint);

      if (Object.keys(endPoint).length > 1) {
        mathUtil.clonePoint(leftEdge.end, oldLeftEdgeEndPoint);
        mathUtil.clonePoint(rightEdge.end, oldRightEdgeEndPoint);
      }
    }

    return newRoad.vectorId;
  }

  // roadId的两个端点分别是pointId1,pointId2，获取这个roadId
  getRoadId(pointId1, pointId2) {
    const point1 = dataService.getRoadPoint(pointId1);
    const point2 = dataService.getRoadPoint(pointId2);
    // 公路可能删除了。
    if (!point1 || !point2) {
      console.warn("pointId1或者pointId2不存在");
      return null;
    }
    if (pointId1 == pointId2) {
      console.warn("给的是同一个point");
      return null;
    }

    const parent1 = point1.parent;
    const parent2 = point2.parent;

    for (const key in parent1) {
      if (parent2.hasOwnProperty(key)) {
        return key;
      }
    }

    return null;
  }

  getNeighPoints(pointId, exceptPointId) {
    let points = [];
    let point = dataService.getRoadPoint(pointId);
    for (let key in point.parent) {
      let road = dataService.getRoad(key);
      const otherPointId = road.getOtherPointId(pointId);
      if (exceptPointId && exceptPointId == otherPointId) {
        continue;
      }
      const otherPoint = dataService.getRoadPoint(otherPointId);
      points.push(otherPoint);
    }
    return points;
  }

  // id1和id2不相交
  AngleForRoad(id1, id2) {
    const road1 = dataService.getRoad(id1);
    const road2 = dataService.getRoad(id2);

    if (
      road1 == null ||
      road2 == null ||
      typeof road1 === "undefined" ||
      typeof road2 === "undefined"
    ) {
      return null;
    }

    const start1 = dataService.getRoadPoint(road1.startId);
    const end1 = dataService.getRoadPoint(road1.endId);

    const start2 = dataService.getRoadPoint(road2.startId);
    const end2 = dataService.getRoadPoint(road2.endId);

    const distance1 = mathUtil.getDistance(start1, start2);
    const distance2 = mathUtil.getDistance(start1, end2);

    const distance3 = mathUtil.getDistance(end1, start2);
    const distance4 = mathUtil.getDistance(end1, end2);

    const minDistance = Math.min(distance1, distance2, distance3, distance4);
    const join = mathUtil.getIntersectionPoint2(start1, end1, start2, end2);

    if (join == null) {
      return 180;
    }

    // start和start相交
    if (distance1 == minDistance) {
      end1.x += start2.x - start1.x;
      end1.y += start2.y - start1.y;
      return mathUtil.Angle(start2, end1, end2);
    } else if (distance2 == minDistance) {
      end1.x += end2.x - start1.x;
      end1.y += end2.y - start1.y;
      return mathUtil.Angle(end2, end1, start2);
    } else if (distance3 == minDistance) {
      start1.x += start2.x - end1.x;
      start1.y += start2.y - end1.y;
      return mathUtil.Angle(start2, start1, end2);
    } else if (distance4 == minDistance) {
      start1.x += end2.x - end1.x;
      start1.y += end2.y - end1.y;
      return mathUtil.Angle(end2, start1, start2);
    } else {
      console.error("AngleForRoad**************************1");
      return null;
    }
  }

  // 除了返回角度，还返回：id1对应的start,end和id2对应的另外一点组成的三角形，是顺时针还是逆时针
  AngleForRoad2(id1, id2) {
    const road1 = dataService.getRoad(id1);
    const road2 = dataService.getRoad(id2);

    if (
      road1 == null ||
      road2 == null ||
      typeof road1 === "undefined" ||
      typeof road2 === "undefined"
    ) {
      return null;
    }

    const start1 = dataService.getRoadPoint(road1.startId);
    const end1 = dataService.getRoadPoint(road1.endId);

    const start2 = dataService.getRoadPoint(road2.startId);
    const end2 = dataService.getRoadPoint(road2.endId);

    let angle = null;
    const points = [];
    points.push(start1);
    points.push(end1);
    if (road1.startId == road2.startId) {
      angle = mathUtil.Angle(start1, end1, end2);
      points.push(end2);
    } else if (road1.startId == road2.endId) {
      angle = mathUtil.Angle(start1, end1, start2);
      points.push(start2);
    } else if (road1.endId == road2.startId) {
      angle = mathUtil.Angle(end1, start1, end2);
      points[0] = end1;
      points[1] = start1;
      points.push(end2);
    } else if (road1.endId == road2.endId) {
      angle = mathUtil.Angle(end1, start1, start2);
      points[0] = end1;
      points[1] = start1;
      points.push(start2);
    }

    if (angle == null) {
      return null;
    } else {
      const flag = mathUtil.isClockwise(points);
      if (flag) {
        return {
          angle: angle,
          clockwise: 1,
        };
      } else {
        return {
          angle: angle,
          clockwise: 0,
        };
      }
    }
  }

  // id1的端点坐标不变
  AngleForRoad3(id1, id2) {
    const road1 = dataService.getRoad(id1);
    const road2 = dataService.getRoad(id2);

    if (
      road1 == null ||
      road2 == null ||
      typeof road1 === "undefined" ||
      typeof road2 === "undefined"
    ) {
      return null;
    }

    const start1 = dataService.getRoadPoint(road1.startId);
    const end1 = dataService.getRoadPoint(road1.endId);

    const start2 = dataService.getRoadPoint(road2.startId);
    const end2 = dataService.getRoadPoint(road2.endId);

    const distance1 = mathUtil.getDistance(start1, start2);
    const distance2 = mathUtil.getDistance(start1, end2);

    const distance3 = mathUtil.getDistance(end1, start2);
    const distance4 = mathUtil.getDistance(end1, end2);

    const minDistance = Math.min(distance1, distance2, distance3, distance4);

    const _start1 = {};
    const _end1 = {};

    // start和start相交
    if (distance1 == minDistance) {
      _end1.x = end1.x + start2.x - start1.x;
      _end1.y = end1.y + start2.y - start1.y;
      return mathUtil.Angle(start2, _end1, end2);
    } else if (distance2 == minDistance) {
      _end1.x = end1.x + end2.x - start1.x;
      _end1.y = end1.y + end2.y - start1.y;
      return mathUtil.Angle(end2, _end1, start2);
    } else if (distance3 == minDistance) {
      _start1.x = start1.x + start2.x - end1.x;
      _start1.y = start1.y + start2.y - end1.y;
      return mathUtil.Angle(start2, _start1, end2);
    } else if (distance4 == minDistance) {
      _start1.x = start1.x + end2.x - end1.x;
      _start1.y = start1.y + end2.y - end1.y;
      return mathUtil.Angle(end2, _start1, start2);
    } else {
      console.error(
        "RoadService.AngleForRoad3************************************1"
      );
      return null;
    }
  }

  // pointId的parent超过两个
  // 获取最小角度（顺时针和逆时针）
  // 可能缺顺时针或者逆时针，这时候对应的取最大角度的逆时针或者顺时针
  roadIdForMinAngle(pointId, roadId) {
    const point = dataService.getRoadPoint(pointId);
    const parent = point.parent;

    let minAngle0 = null;
    let maxAngle0 = null; // 可能minAngle1不存在，这时候要找逆时针最大的
    let minAngle1 = null;
    let maxAngle1 = null;

    let minInfo0, minInfo1;
    let maxInfo0, maxInfo1;

    if (Object.keys(parent).length > 2) {
      for (const key in parent) {
        if (key == roadId) {
          continue;
        }
        const angleInfo = this.AngleForRoad2(roadId, key);
        if (minAngle1 == null && angleInfo.clockwise == 1) {
          minInfo1 = angleInfo;
          minInfo1.roadId = key;
          minAngle1 = angleInfo.angle;

          maxInfo1 = angleInfo;
          maxInfo1.roadId = key;
          maxAngle1 = angleInfo.angle;
        } else if (minAngle1 > angleInfo.angle && angleInfo.clockwise == 1) {
          minInfo1 = angleInfo;
          minInfo1.roadId = key;
          minAngle1 = angleInfo.angle;
        } else if (maxAngle1 < angleInfo.angle && angleInfo.clockwise == 1) {
          maxInfo1 = angleInfo;
          maxInfo1.roadId = key;
          maxAngle1 = angleInfo.angle;
        } else if (minAngle0 == null && angleInfo.clockwise == 0) {
          minInfo0 = angleInfo;
          minInfo0.roadId = key;
          minAngle0 = angleInfo.angle;

          maxInfo0 = angleInfo;
          maxInfo0.roadId = key;
          maxAngle0 = angleInfo.angle;
        } else if (minAngle0 > angleInfo.angle && angleInfo.clockwise == 0) {
          minInfo0 = angleInfo;
          minInfo0.roadId = key;
          minAngle0 = angleInfo.angle;
        } else if (maxAngle0 < angleInfo.angle && angleInfo.clockwise == 0) {
          maxInfo0 = angleInfo;
          maxInfo0.roadId = key;
          maxAngle0 = angleInfo.angle;
        }
      }

      const result = {
        min0: minInfo0,
        min1: minInfo1,
      };

      if (!result.min0) {
        result.min0 = maxInfo1;
        result.min0.angle = 360 - maxInfo1.angle;
      }

      if (!result.min1) {
        result.min1 = maxInfo0;
        result.min1.angle = 360 - maxInfo0.angle;
      }

      return result;
    } else {
      console.error(
        "roadIdForMinAngle*********************************************************"
      );
      return null;
    }
  }

  isRoadLink(roadId1, roadId2) {
    let road1 = dataService.getRoad(roadId1);
    let road2 = dataService.getRoad(roadId2);

    if (
      road1.startId == road2.startId ||
      road1.startId == road2.endId ||
      road1.endId == road2.startId ||
      road1.endId == road2.endId
    ) {
      return true;
    } else {
      return false;
    }
  }

  //point在road所在的线上，只是不确定是否在线段上
  isContain(road, point) {
    const startPoint = dataService.getRoadPoint(road.startId);
    const endPoint = dataService.getRoadPoint(road.endId);
    const minDis = Constant.minAdsorbPix / 2;
    return mathUtil.isContainForSegment(point, startPoint, endPoint, minDis);
  }

  getDirction(pointId, roadId) {
    const road = dataService.getRoad(roadId);
    if (road.startId == pointId) {
      return "start";
    } else if (road.endId == pointId) {
      return "end";
    } else {
      console.error(
        "RoadService.getDirction*******************************************************************************************"
      );
      return null;
    }
  }

  subtraRoadFromIntersect(pointId, roadId) {
    const point = dataService.getRoadPoint(pointId);
    const parent = point.getParent();
    const dir = this.getDirction(pointId, roadId);

    if (Object.keys(parent).length == 1) {
      return;
    } else if (Object.keys(parent).length > 2) {
      const info = this.roadIdForMinAngle(pointId, roadId);
      edgeService.updateSingleEdgeForTwoRoad(
        info.min0.roadId,
        info.min1.roadId
      );
    }

    // 第一步先断开链接
    delete parent[roadId];
    // 第二步先新建端点
    const newPoint = roadPointService.create(point);
    // 第三步建立链接
    newPoint.setPointParent(roadId, dir);
    this.setRoadPointId(roadId, newPoint.vectorId, dir);
    // 第四步更新Edge
    edgeService.updateDefaultEdge(roadId, dir);
    this.setLanes(roadId, null, dir);
  }

  deleteRoadForLinked(roadId) {
    const road = dataService.getRoad(roadId);
    this.subtraRoadFromIntersect(road.startId, roadId);
    this.subtraRoadFromIntersect(road.endId, roadId);
    dataService.deleteRoad(roadId);

    dataService.deleteCrossPointForEdge(road.leftEdgeId, "start");
    dataService.deleteCrossPointForEdge(road.leftEdgeId, "end");
    dataService.deleteCrossPointForEdge(road.rightEdgeId, "start");
    dataService.deleteCrossPointForEdge(road.rightEdgeId, "end");
  }

  setRoadPointId(roadId, pointId, dir) {
    const vectorInfo = {};
    vectorInfo.roadId = roadId;
    vectorInfo.dir = dir;
    vectorInfo.pointId = pointId;
    this.setRoadInfo(vectorInfo);
  }

  setRoadInfo(vectorInfo) {
    const road = dataService.getRoad(vectorInfo.roadId);
    if (
      vectorInfo.hasOwnProperty("edgeId") &&
      vectorInfo.hasOwnProperty("dir")
    ) {
      if (vectorInfo.dir == "left") {
        road.leftEdgeId = vectorInfo.edgeId;
      } else if (vectorInfo.dir == "right") {
        road.rightEdgeId = vectorInfo.edgeId;
      }
    }

    if (
      vectorInfo.hasOwnProperty("pointId") &&
      vectorInfo.hasOwnProperty("dir")
    ) {
      if (vectorInfo.dir == "start") {
        road.startId = vectorInfo.pointId;
      } else if (vectorInfo.dir == "end") {
        road.endId = vectorInfo.pointId;
      }
    }
  }

  AngleForRoad2(id1, id2) {
    let road1 = dataService.getRoad(id1);
    let road2 = dataService.getRoad(id2);

    if (
      road1 == null ||
      road2 == null ||
      typeof road1 == "undefined" ||
      typeof road2 == "undefined"
    ) {
      return null;
    }

    let start1 = dataService.getRoadPoint(road1.startId);
    let end1 = dataService.getRoadPoint(road1.endId);

    let start2 = dataService.getRoadPoint(road2.startId);
    let end2 = dataService.getRoadPoint(road2.endId);

    let angle = null;
    let points = [];
    points.push(start1);
    points.push(end1);
    if (road1.startId == road2.startId) {
      angle = mathUtil.Angle(start1, end1, end2);
      points.push(end2);
    } else if (road1.startId == road2.endId) {
      angle = mathUtil.Angle(start1, end1, start2);
      points.push(start2);
    } else if (road1.endId == road2.startId) {
      angle = mathUtil.Angle(end1, start1, end2);
      points[0] = end1;
      points[1] = start1;
      points.push(end2);
    } else if (road1.endId == road2.endId) {
      angle = mathUtil.Angle(end1, start1, start2);
      points[0] = end1;
      points[1] = start1;
      points.push(start2);
    }

    if (angle == null) {
      return null;
    } else {
      let flag = mathUtil.isClockwise(points);
      if (flag) {
        return {
          angle: angle,
          clockwise: 1,
        };
      } else {
        return {
          angle: angle,
          clockwise: 0,
        };
      }
    }
  }

  //pointId的parent超过两个
  //获取最小角度（顺时针和逆时针）
  //可能缺顺时针或者逆时针，这时候对应的取最大角度的逆时针或者顺时针
  roadIdForMinAngle(pointId, roadId) {
    let point = dataService.getRoadPoint(pointId);
    let parent = point.getParent();

    let minAngle0 = null;
    let maxAngle0 = null; //可能minAngle1不存在，这时候要找逆时针最大的
    let minAngle1 = null;
    let maxAngle1 = null;

    let minInfo0, minInfo1;
    let maxInfo0, maxInfo1;

    if (Object.keys(parent).length > 2) {
      for (let key in parent) {
        if (key == roadId) {
          continue;
        }
        let angleInfo = this.AngleForRoad2(roadId, key);
        if (minAngle1 == null && angleInfo.clockwise == 1) {
          minInfo1 = angleInfo;
          minInfo1.roadId = key;
          minAngle1 = angleInfo.angle;

          maxInfo1 = angleInfo;
          maxInfo1.roadId = key;
          maxAngle1 = angleInfo.angle;
        } else if (minAngle1 > angleInfo.angle && angleInfo.clockwise == 1) {
          minInfo1 = angleInfo;
          minInfo1.roadId = key;
          minAngle1 = angleInfo.angle;
        } else if (maxAngle1 < angleInfo.angle && angleInfo.clockwise == 1) {
          maxInfo1 = angleInfo;
          maxInfo1.roadId = key;
          maxAngle1 = angleInfo.angle;
        } else if (minAngle0 == null && angleInfo.clockwise == 0) {
          minInfo0 = angleInfo;
          minInfo0.roadId = key;
          minAngle0 = angleInfo.angle;

          maxInfo0 = angleInfo;
          maxInfo0.roadId = key;
          maxAngle0 = angleInfo.angle;
        } else if (minAngle0 > angleInfo.angle && angleInfo.clockwise == 0) {
          minInfo0 = angleInfo;
          minInfo0.roadId = key;
          minAngle0 = angleInfo.angle;
        } else if (maxAngle0 < angleInfo.angle && angleInfo.clockwise == 0) {
          maxInfo0 = angleInfo;
          maxInfo0.roadId = key;
          maxAngle0 = angleInfo.angle;
        }
      }

      let result = {
        min0: minInfo0,
        min1: minInfo1,
      };

      if (!result.min0) {
        result.min0 = maxInfo1;
        result.min0.angle = 360 - maxInfo1.angle;
      }

      if (!result.min1) {
        result.min1 = maxInfo0;
        result.min1.angle = 360 - maxInfo0.angle;
      }

      return result;
    } else {
      console.error(
        "roadIdForMinAngle*********************************************************"
      );
      return null;
    }
  }

  getDirction(pointId, roadId) {
    let road = dataService.getRoad(roadId);
    if (road.startId == pointId) {
      return "start";
    } else if (road.endId == pointId) {
      return "end";
    } else {
      console.error(
        "getDirction*******************************************************************************************"
      );
      return null;
    }
  }

  //pointId的parent超过两个
  //获取最小角度（顺时针和逆时针）
  //可能缺顺时针或者逆时针，这时候对应的取最大角度的逆时针或者顺时针
  roadIdForMinAngle(pointId, roadId) {
    let point = dataService.getRoadPoint(pointId);
    let parent = point.parent;

    let minAngle0 = null;
    let maxAngle0 = null; //可能minAngle1不存在，这时候要找逆时针最大的
    let minAngle1 = null;
    let maxAngle1 = null;

    let minInfo0, minInfo1;
    let maxInfo0, maxInfo1;

    if (Object.keys(parent).length > 2) {
      for (let key in parent) {
        if (key == roadId) {
          continue;
        }
        let angleInfo = this.AngleForRoad2(roadId, key);
        if (minAngle1 == null && angleInfo.clockwise == 1) {
          minInfo1 = angleInfo;
          minInfo1.roadId = key;
          minAngle1 = angleInfo.angle;

          maxInfo1 = angleInfo;
          maxInfo1.roadId = key;
          maxAngle1 = angleInfo.angle;
        } else if (minAngle1 > angleInfo.angle && angleInfo.clockwise == 1) {
          minInfo1 = angleInfo;
          minInfo1.roadId = key;
          minAngle1 = angleInfo.angle;
        } else if (maxAngle1 < angleInfo.angle && angleInfo.clockwise == 1) {
          maxInfo1 = angleInfo;
          maxInfo1.roadId = key;
          maxAngle1 = angleInfo.angle;
        } else if (minAngle0 == null && angleInfo.clockwise == 0) {
          minInfo0 = angleInfo;
          minInfo0.roadId = key;
          minAngle0 = angleInfo.angle;

          maxInfo0 = angleInfo;
          maxInfo0.roadId = key;
          maxAngle0 = angleInfo.angle;
        } else if (minAngle0 > angleInfo.angle && angleInfo.clockwise == 0) {
          minInfo0 = angleInfo;
          minInfo0.roadId = key;
          minAngle0 = angleInfo.angle;
        } else if (maxAngle0 < angleInfo.angle && angleInfo.clockwise == 0) {
          maxInfo0 = angleInfo;
          maxInfo0.roadId = key;
          maxAngle0 = angleInfo.angle;
        }
      }

      let result = {
        min0: minInfo0,
        min1: minInfo1,
      };

      if (!result.min0) {
        result.min0 = maxInfo1;
        result.min0.angle = 360 - maxInfo1.angle;
      }

      if (!result.min1) {
        result.min1 = maxInfo0;
        result.min1.angle = 360 - maxInfo0.angle;
      }

      return result;
    } else {
      console.error(
        "roadIdForMinAngle*********************************************************"
      );
      return null;
    }
  }

  deleteRoad(roadId) {
    const road = dataService.getRoad(roadId);
    let startPoint = dataService.getRoadPoint(road.startId);
    let endPoint = dataService.getRoadPoint(road.endId);
    if (Object.keys(startPoint.getParent()).length > 2) {
      this.subtraRoadFromIntersect(road.startId, roadId);
    }
    if (Object.keys(endPoint.getParent()).length > 2) {
      this.subtraRoadFromIntersect(road.endId, roadId);
    }
  }
  /****************************************************************************************************************************************************************/

  // updateDrivewayCount(roadId, dir, type) {
  //   let road = dataService.getRoad(roadId);
  //   if (dir == "left") {
  //     if (type == "add") {
  //       ++road.leftDrivewayCount;
  //     } else if (type == "sub") {
  //       --road.leftDrivewayCount;
  //       if (road.leftDrivewayCount < 0) {
  //         road.leftDrivewayCount = 0;
  //       }
  //     }
  //   } else if (dir == "right") {
  //     if (type == "add") {
  //       ++road.rightDrivewayCount;
  //     } else if (type == "sub") {
  //       --road.rightDrivewayCount;
  //       if (road.rightDrivewayCount < 0) {
  //         road.rightDrivewayCount = 0;
  //       }
  //     }
  //   }
  // }

  //设置中间带
  setMidDivide(roadId, dir) {
    const road = dataService.getRoad(roadId);
    const startPoint = dataService.getRoadPoint(road.startId);
    const endPoint = dataService.getRoadPoint(road.endId);
    const leftEdge = dataService.getRoadEdge(road.leftEdgeId);
    const rightEdge = dataService.getRoadEdge(road.rightEdgeId);

    //离中心最近的点才是中间带的起点和终点
    const mid = {
      x: (startPoint.x + endPoint.x) / 2,
      y: (startPoint.y + endPoint.y) / 2,
    };
    let line = this.getMidLine(road);
    const startJoin1 = mathUtil.getJoinLinePoint(leftEdge.start, line);
    const startJoin2 = mathUtil.getJoinLinePoint(rightEdge.start, line);
    const distance1 = mathUtil.getDistance(startJoin1, mid);
    const distance2 = mathUtil.getDistance(startJoin2, mid);

    let laneStart, laneEnd, join;

    if (!dir || dir == "start") {
      if (distance1 > distance2) {
        laneStart = {
          x: startJoin2.x,
          y: startJoin2.y,
        };
      } else {
        laneStart = {
          x: startJoin1.x,
          y: startJoin1.y,
        };
      }

      if (road.way == Constant.twoWay) {
        //更新车道的起点和终点，因为车道的起点和终点的位置与中间隔离栏一致
        for (let i = 0; i < road.leftLanes.length; ++i) {
          line = mathUtil.createLine1(
            road.leftLanes[i].start,
            road.leftLanes[i].end
          );
          join = mathUtil.getJoinLinePoint(laneStart, line);
          mathUtil.clonePoint(road.leftLanes[i].start, join);
        }
        for (let i = 0; i < road.rightLanes.length; ++i) {
          line = mathUtil.createLine1(
            road.rightLanes[i].start,
            road.rightLanes[i].end
          );
          join = mathUtil.getJoinLinePoint(laneStart, line);
          mathUtil.clonePoint(road.rightLanes[i].start, join);
        }
        line = mathUtil.createLine1(
          road.midDivide.leftMidDivide.start,
          road.midDivide.leftMidDivide.end
        );
        join = mathUtil.getJoinLinePoint(laneStart, line);
        mathUtil.clonePoint(road.midDivide.leftMidDivide.start, join);

        line = mathUtil.createLine1(
          road.midDivide.rightMidDivide.start,
          road.midDivide.rightMidDivide.end
        );
        join = mathUtil.getJoinLinePoint(laneStart, line);
        mathUtil.clonePoint(road.midDivide.rightMidDivide.start, join);
      } else if (road.way == Constant.oneWay) {
        for (let i = 0; i < road.singleLanes.length; ++i) {
          const line = mathUtil.createLine1(
            road.singleLanes[i].start,
            road.singleLanes[i].end
          );
          const join = mathUtil.getJoinLinePoint(laneStart, line);
          mathUtil.clonePoint(road.singleLanes[i].start, join);
        }
      }
    }

    const endJoin1 = mathUtil.getJoinLinePoint(leftEdge.end, line);
    const endJoin2 = mathUtil.getJoinLinePoint(rightEdge.end, line);
    const distance3 = mathUtil.getDistance(endJoin1, mid);
    const distance4 = mathUtil.getDistance(endJoin2, mid);
    if (!dir || dir == "end") {
      if (distance3 > distance4) {
        laneEnd = {
          x: endJoin2.x,
          y: endJoin2.y,
        };
      } else {
        laneEnd = {
          x: endJoin1.x,
          y: endJoin1.y,
        };
      }

      if (road.way == Constant.twoWay) {
        //更新车道的起点和终点，因为车道的起点和终点的位置与中间隔离栏一致
        for (let i = 0; i < road.leftLanes.length; ++i) {
          line = mathUtil.createLine1(
            road.leftLanes[i].start,
            road.leftLanes[i].end
          );
          join = mathUtil.getJoinLinePoint(laneEnd, line);
          mathUtil.clonePoint(road.leftLanes[i].end, join);
        }
        for (let i = 0; i < road.rightLanes.length; ++i) {
          line = mathUtil.createLine1(
            road.rightLanes[i].start,
            road.rightLanes[i].end
          );
          join = mathUtil.getJoinLinePoint(laneEnd, line);
          mathUtil.clonePoint(road.rightLanes[i].end, join);
        }
        line = mathUtil.createLine1(
          road.midDivide.leftMidDivide.start,
          road.midDivide.leftMidDivide.end
        );
        join = mathUtil.getJoinLinePoint(laneEnd, line);
        mathUtil.clonePoint(road.midDivide.leftMidDivide.end, join);

        line = mathUtil.createLine1(
          road.midDivide.rightMidDivide.start,
          road.midDivide.rightMidDivide.end
        );
        join = mathUtil.getJoinLinePoint(laneEnd, line);
        mathUtil.clonePoint(road.midDivide.rightMidDivide.end, join);
      } else if (road.way == Constant.oneWay) {
        for (let i = 0; i < road.singleLanes.length; ++i) {
          const line = mathUtil.createLine1(
            road.singleLanes[i].start,
            road.singleLanes[i].end
          );
          const join = mathUtil.getJoinLinePoint(laneEnd, line);
          mathUtil.clonePoint(road.singleLanes[i].end, join);
        }
      }
    }
  }

  //设置车道
  //dir1表示left或者right，dir2表示start或者end
  //单车道不考虑dir1
  setLanes(roadId, dir1, dir2) {
    let road = dataService.getRoad(roadId);
    if(!road){
      return
    }
    if (road.way == Constant.oneWay) {
      this.setOneWayLanes(road, dir1, dir2);
    } else if (road.way == Constant.twoWay) {
      this.setTwoWayLanes(road, dir1, dir2);
    }
  }

  //单向车道
  setOneWayLanes(road, dir1, dir2) {
    let leftEdge = dataService.getRoadEdge(road.leftEdgeId);
    let rightEdge = dataService.getRoadEdge(road.rightEdgeId);
    const drivewayCount = road.singleRoadDrivewayCount;

    let dx1 = (leftEdge.start.x - rightEdge.start.x) / drivewayCount;
    let dy1 = (leftEdge.start.y - rightEdge.start.y) / drivewayCount;

    let dx2 = (leftEdge.end.x - rightEdge.end.x) / drivewayCount;
    let dy2 = (leftEdge.end.y - rightEdge.end.y) / drivewayCount;

    road.singleLanes = [];
    for (let i = 0; i < drivewayCount - 1; ++i) {
      if (!road.singleLanes[i]) {
        road.singleLanes[i] = {};
      }

      if (dir2 == "start" || !dir2) {
        road.singleLanes[i].start = {};
        road.singleLanes[i].start.x = rightEdge.start.x + dx1 * (i + 1);
        road.singleLanes[i].start.y = rightEdge.start.y + dy1 * (i + 1);
      }

      if (dir2 == "end" || !dir2) {
        road.singleLanes[i].end = {};
        road.singleLanes[i].end.x = rightEdge.end.x + dx2 * (i + 1);
        road.singleLanes[i].end.y = rightEdge.end.y + dy2 * (i + 1);
      }
    }
  }

  //双向车道
  setTwoWayLanes(road, dir1, dir2) {
    let startPoint = dataService.getRoadPoint(road.startId);
    let endPoint = dataService.getRoadPoint(road.endId);
    let leftEdge = dataService.getRoadEdge(road.leftEdgeId);
    let rightEdge = dataService.getRoadEdge(road.rightEdgeId);

    if (!road.midDivide) {
      road.midDivide = {
        leftMidDivide: {},
        rightMidDivide: {},
      };
    }

    const leftCount = road.leftDrivewayCount;
    const rightCount = road.rightDrivewayCount;
    const leftRatio =
      road.leftWidth / (road.leftWidth + road.midDivide.midDivideWidth / 2);
    const rightRatio =
      road.rightWidth / (road.rightWidth + road.midDivide.midDivideWidth / 2);

    let leftdx1 = ((leftEdge.start.x - startPoint.x) * leftRatio) / leftCount;
    let leftdy1 = ((leftEdge.start.y - startPoint.y) * leftRatio) / leftCount;

    let leftdx2 = ((leftEdge.end.x - endPoint.x) * leftRatio) / leftCount;
    let leftdy2 = ((leftEdge.end.y - endPoint.y) * leftRatio) / leftCount;

    let rightdx1 =
      ((rightEdge.start.x - startPoint.x) * rightRatio) / rightCount;
    let rightdy1 =
      ((rightEdge.start.y - startPoint.y) * rightRatio) / rightCount;

    let rightdx2 = ((rightEdge.end.x - endPoint.x) * rightRatio) / rightCount;
    let rightdy2 = ((rightEdge.end.y - endPoint.y) * rightRatio) / rightCount;

    if (dir1 == "left" || !dir1) {
      let middx1 = (leftEdge.start.x - startPoint.x) * (1 - leftRatio);
      let middy1 = (leftEdge.start.y - startPoint.y) * (1 - leftRatio);
      let middx2 = (leftEdge.end.x - endPoint.x) * (1 - leftRatio);
      let middy2 = (leftEdge.end.y - endPoint.y) * (1 - leftRatio);
      for (let i = 0; i < leftCount - 1; ++i) {
        if (!road.leftLanes[i]) {
          road.leftLanes[i] = {};
        }

        if (dir2 == "start" || !dir2) {
          road.leftLanes[i].start = {};
          road.leftLanes[i].start.x = startPoint.x + middx1 + leftdx1 * (i + 1);
          road.leftLanes[i].start.y = startPoint.y + middy1 + leftdy1 * (i + 1);

          road.midDivide.leftMidDivide.start = {};
          road.midDivide.leftMidDivide.start.x = startPoint.x + middx1;
          road.midDivide.leftMidDivide.start.y = startPoint.y + middy1;
        }

        if (dir2 == "end" || !dir2) {
          road.leftLanes[i].end = {};
          road.leftLanes[i].end.x = endPoint.x + middx2 + leftdx2 * (i + 1);
          road.leftLanes[i].end.y = endPoint.y + middy2 + leftdy2 * (i + 1);

          road.midDivide.leftMidDivide.end = {};
          road.midDivide.leftMidDivide.end.x = endPoint.x + middx1;
          road.midDivide.leftMidDivide.end.y = endPoint.y + middy2;
        }
      }
      if (dir2 == "start" || !dir2) {
        road.midDivide.leftMidDivide.start = {};
        road.midDivide.leftMidDivide.start.x = startPoint.x + middx1;
        road.midDivide.leftMidDivide.start.y = startPoint.y + middy1;
      }
      if (dir2 == "end" || !dir2) {
        road.midDivide.leftMidDivide.end = {};
        road.midDivide.leftMidDivide.end.x = endPoint.x + middx2;
        road.midDivide.leftMidDivide.end.y = endPoint.y + middy2;
      }

      road.leftLanes.splice(leftCount - 1);
    }

    if (dir1 == "right" || !dir1) {
      let middx1 = (rightEdge.start.x - startPoint.x) * (1 - rightRatio);
      let middy1 = (rightEdge.start.y - startPoint.y) * (1 - rightRatio);
      let middx2 = (rightEdge.end.x - endPoint.x) * (1 - rightRatio);
      let middy2 = (rightEdge.end.y - endPoint.y) * (1 - rightRatio);
      for (let i = 0; i < rightCount - 1; ++i) {
        if (!road.rightLanes[i]) {
          road.rightLanes[i] = {};
        }

        if (dir2 == "start" || !dir2) {
          road.rightLanes[i].start = {};
          road.rightLanes[i].start.x =
            startPoint.x + middx1 + rightdx1 * (i + 1);
          road.rightLanes[i].start.y =
            startPoint.y + middy1 + rightdy1 * (i + 1);

          road.midDivide.rightMidDivide.start = {};
          road.midDivide.rightMidDivide.start.x = startPoint.x + middx1;
          road.midDivide.rightMidDivide.start.y = startPoint.y + middy1;
        }

        if (dir2 == "end" || !dir2) {
          road.rightLanes[i].end = {};
          road.rightLanes[i].end.x = endPoint.x + middx2 + rightdx2 * (i + 1);
          road.rightLanes[i].end.y = endPoint.y + middy2 + rightdy2 * (i + 1);

          road.midDivide.rightMidDivide.end = {};
          road.midDivide.rightMidDivide.end.x = endPoint.x + middx2;
          road.midDivide.rightMidDivide.end.y = endPoint.y + middy2;
        }
      }

      if (dir2 == "start" || !dir2) {
        road.midDivide.rightMidDivide.start = {};
        road.midDivide.rightMidDivide.start.x = startPoint.x + middx1;
        road.midDivide.rightMidDivide.start.y = startPoint.y + middy1;
      }
      if (dir2 == "end" || !dir2) {
        road.midDivide.rightMidDivide.end = {};
        road.midDivide.rightMidDivide.end.x = endPoint.x + middx2;
        road.midDivide.rightMidDivide.end.y = endPoint.y + middy2;
      }

      road.rightLanes.splice(rightCount - 1);
    }
    this.setMidDivide(road.vectorId);
  }

  // singleToMullane(road) {
  //   road.leftDrivewayCount = 1;
  //   road.rightDrivewayCount = 1;
  //   this.setMidDivide(road.vectorId);
  //   this.setLanes(road.vectorId);
  // }

  //多车道转单车道
  mulToSinglelane(road) {
    if (road.leftDrivewayCount > 0) {
      this.updateForAddSubtractLanesCount(road.vectorId, 1, "left");
    }
    if (road.rightDrivewayCount > 0) {
      this.updateForAddSubtractLanesCount(road.vectorId, 1, "right");
    }
    road.leftDrivewayCount = 0;
    road.rightDrivewayCount = 0;
    road.leftLanes = [];
    road.rightLanes = [];
    this.setMidDivide(road.vectorId);
  }

  //删除或者减少车道
  //需要考虑车道个数是0(左或者右)的情况
  //单向车道不考虑dir，即：均匀的增加或者删除车道
  updateForAddSubtractLanesCount(roadId, newCount, dir) {
    let dx1,
      dy1,
      dx2,
      dy2,
      oldCount,
      edgeStartPosition,
      edgeEndPosition,
      leftRatio,
      rightRatio,
      middx1,
      middy1,
      middx2,
      middy2;
    let road = dataService.getRoad(roadId);

    if (newCount < 1) {
      return;
    }

    let startPoint = dataService.getRoadPoint(road.startId);
    let endPoint = dataService.getRoadPoint(road.endId);
    let leftEdge = dataService.getRoadEdge(road.leftEdgeId);
    let rightEdge = dataService.getRoadEdge(road.rightEdgeId);

    if (road.way == Constant.twoWay) {
      leftRatio =
        road.leftWidth / (road.leftWidth + road.midDivide.midDivideWidth / 2);
      rightRatio =
        road.rightWidth / (road.rightWidth + road.midDivide.midDivideWidth / 2);
      if (dir == "left") {
        oldCount = road.leftDrivewayCount;
        if (oldCount != 0) {
          dx1 = ((leftEdge.start.x - startPoint.x) * leftRatio) / oldCount;
          dy1 = ((leftEdge.start.y - startPoint.y) * leftRatio) / oldCount;

          dx2 = ((leftEdge.end.x - endPoint.x) * leftRatio) / oldCount;
          dy2 = ((leftEdge.end.y - endPoint.y) * leftRatio) / oldCount;
        }

        middx1 = (leftEdge.start.x - startPoint.x) * (1 - leftRatio);
        middy1 = (leftEdge.start.y - startPoint.y) * (1 - leftRatio);
        middx2 = (leftEdge.end.x - endPoint.x) * (1 - leftRatio);
        middy2 = (leftEdge.end.y - endPoint.y) * (1 - leftRatio);

        road.leftDrivewayCount = newCount;
      } else if (dir == "right") {
        oldCount = road.rightDrivewayCount;
        if (oldCount != 0) {
          dx1 = ((rightEdge.start.x - startPoint.x) * rightRatio) / oldCount;
          dy1 = ((rightEdge.start.y - startPoint.y) * rightRatio) / oldCount;

          dx2 = ((rightEdge.end.x - endPoint.x) * rightRatio) / oldCount;
          dy2 = ((rightEdge.end.y - endPoint.y) * rightRatio) / oldCount;
        }
        middx1 = (rightEdge.start.x - startPoint.x) * (1 - rightRatio);
        middy1 = (rightEdge.start.y - startPoint.y) * (1 - rightRatio);
        middx2 = (rightEdge.end.x - endPoint.x) * (1 - rightRatio);
        middy2 = (rightEdge.end.y - endPoint.y) * (1 - rightRatio);

        road.rightDrivewayCount = newCount;
      }
    }

    if (newCount == oldCount) {
      return;
    } else if (newCount == 0) {
      this.mulToSinglelane(road);
      return;
    } else if (oldCount == 0) {
      this.singleToMullane(road);
      return;
    }

    if (road.way == Constant.twoWay) {
      edgeStartPosition = {
        x: startPoint.x + middx1 + dx1 * newCount,
        y: startPoint.y + middy1 + dy1 * newCount,
      };
      edgeEndPosition = {
        x: endPoint.x + middx2 + dx2 * newCount,
        y: endPoint.y + middy2 + dy2 * newCount,
      };

      if (dir == "left") {
        mathUtil.clonePoint(leftEdge.start, edgeStartPosition);
        mathUtil.clonePoint(leftEdge.end, edgeEndPosition);
      } else if (dir == "right") {
        mathUtil.clonePoint(rightEdge.start, edgeStartPosition);
        mathUtil.clonePoint(rightEdge.end, edgeEndPosition);
      }

      let line = this.getMidLine(road);
      if (dir == "left") {
        let join = mathUtil.getJoinLinePoint(leftEdge.start, line);
        road.setWidth(
          mathUtil.getDistance(leftEdge.start, join) -
            road.midDivide.midDivideWidth / 2,
          dir
        );
      } else if (dir == "right") {
        let join = mathUtil.getJoinLinePoint(rightEdge.start, line);
        road.setWidth(
          mathUtil.getDistance(rightEdge.start, join) -
            road.midDivide.midDivideWidth / 2,
          dir
        );
      }
    } else if (road.way == Constant.oneWay) {
      oldCount = road.singleRoadDrivewayCount;
      //不能从leftEdge直接到rightEdge，因为不一定是线性的
      dx1 = ((leftEdge.start.x - startPoint.x) / oldCount) * newCount;
      dy1 = ((leftEdge.start.y - startPoint.y) / oldCount) * newCount;
      dx2 = ((leftEdge.end.x - endPoint.x) / oldCount) * newCount;
      dy2 = ((leftEdge.end.y - endPoint.y) / oldCount) * newCount;

      edgeStartPosition = {
        x: startPoint.x + dx1,
        y: startPoint.y + dy1,
      };
      edgeEndPosition = {
        x: endPoint.x + dx2,
        y: endPoint.y + dy2,
      };
      mathUtil.clonePoint(leftEdge.start, edgeStartPosition);
      mathUtil.clonePoint(leftEdge.end, edgeEndPosition);

      dx1 = ((rightEdge.start.x - startPoint.x) / oldCount) * newCount;
      dy1 = ((rightEdge.start.y - startPoint.y) / oldCount) * newCount;
      dx2 = ((rightEdge.end.x - endPoint.x) / oldCount) * newCount;
      dy2 = ((rightEdge.end.y - endPoint.y) / oldCount) * newCount;

      edgeStartPosition = {
        x: startPoint.x + dx1,
        y: startPoint.y + dy1,
      };
      edgeEndPosition = {
        x: endPoint.x + dx2,
        y: endPoint.y + dy2,
      };
      mathUtil.clonePoint(rightEdge.start, edgeStartPosition);
      mathUtil.clonePoint(rightEdge.end, edgeEndPosition);

      const line = mathUtil.createLine1(leftEdge.start, leftEdge.end);
      const singleRoadWidth = mathUtil.getDisForPoinLine(rightEdge.start, line);
      road.setWidth(singleRoadWidth);
      road.singleRoadDrivewayCount = newCount;
    }

    edgeService.updateEdgeForMulRoad(road.startId);
    edgeService.updateEdgeForMulRoad(road.endId);
    this.setLanes(roadId, dir);
  }

  //变宽或者变窄（车道个数不变）
  //单向的情况下，左右两边同时变宽或者变窄，即：dir无效
  updateForWidth(roadId, newWidth, dir) {
    let road = dataService.getRoad(roadId);
    let startPoint = dataService.getRoadPoint(road.startId);
    let endPoint = dataService.getRoadPoint(road.endId);
    let leftEdge = dataService.getRoadEdge(road.leftEdgeId);
    let rightEdge = dataService.getRoadEdge(road.rightEdgeId);
    let edgePoints;
    if (road.way == Constant.oneWay) {
      edgePoints = mathUtil.RectangleVertex(startPoint, endPoint, newWidth * 2);
      mathUtil.clonePoint(leftEdge.start, edgePoints.leftEdgeStart);
      mathUtil.clonePoint(leftEdge.end, edgePoints.leftEdgeEnd);
      mathUtil.clonePoint(rightEdge.start, edgePoints.rightEdgeStart);
      mathUtil.clonePoint(rightEdge.end, edgePoints.rightEdgeEnd);
      road.setWidth(newWidth * 2);
    } else if (road.way == Constant.twoWay) {
      if (dir == "left") {
        edgePoints = mathUtil.RectangleVertex(
          startPoint,
          endPoint,
          newWidth + road.midDivide.midDivideWidth / 2
        );
        mathUtil.clonePoint(leftEdge.start, edgePoints.leftEdgeStart);
        mathUtil.clonePoint(leftEdge.end, edgePoints.leftEdgeEnd);
        road.setWidth(newWidth, dir);
      } else if (dir == "right") {
        edgePoints = mathUtil.RectangleVertex(
          startPoint,
          endPoint,
          newWidth + road.midDivide.midDivideWidth / 2
        );
        mathUtil.clonePoint(rightEdge.start, edgePoints.rightEdgeStart);
        mathUtil.clonePoint(rightEdge.end, edgePoints.rightEdgeEnd);
        road.setWidth(newWidth, dir);
      }
      //左右两边的edge同时变宽或者变窄
      else {
        edgePoints = mathUtil.RectangleVertex(
          startPoint,
          endPoint,
          (newWidth * road.leftWidth) / (road.leftWidth + road.rightWidth) +
            road.midDivide.midDivideWidth / 2
        );
        mathUtil.clonePoint(leftEdge.start, edgePoints.leftEdgeStart);
        mathUtil.clonePoint(leftEdge.end, edgePoints.leftEdgeEnd);
        road.setWidth(
          (newWidth * road.leftWidth) / (road.leftWidth + road.rightWidth),
          "left"
        );
        edgePoints = mathUtil.RectangleVertex(
          startPoint,
          endPoint,
          (newWidth * road.rightWidth) / (road.leftWidth + road.rightWidth) +
            road.midDivide.midDivideWidth / 2
        );
        mathUtil.clonePoint(rightEdge.start, edgePoints.rightEdgeStart);
        mathUtil.clonePoint(rightEdge.end, edgePoints.rightEdgeEnd);
        road.setWidth(
          (newWidth * road.rightWidth) / (road.leftWidth + road.rightWidth),
          "right"
        );
      }
    }

    edgeService.updateEdgeForMovePoint(road.startId);
    edgeService.updateEdgeForMovePoint(road.endId);
    this.setLanes(roadId, dir);
  }

  //将道路转换成线条
  convertToLines(roadId) {
    let road = dataService.getRoad(roadId);
    let leftEdge = dataService.getRoadEdge(road.leftEdgeId);
    let rightEdge = dataService.getRoadEdge(road.rightEdgeId);
    let leftLine = lineService.create(leftEdge.start, leftEdge.end);
    leftLine.setStyle(leftEdge.getStyle());
    leftLine.setWeight(leftEdge.getWeight());
    let rightLine = lineService.create(rightEdge.start, rightEdge.end);
    rightLine.setStyle(rightEdge.getStyle());
    rightLine.setWeight(rightEdge.getWeight());
    if (road.way == Constant.oneWay) {
      for (let i = 0; i < road.singleLanes.length; ++i) {
        let laneLine = lineService.create(
          road.singleLanes[i].start,
          road.singleLanes[i].end
        );
        laneLine.setStyle(VectorStyle.SingleDashedLine);
      }
    } else if (road.way == Constant.twoWay) {
      for (let i = 0; i < road.leftLanes.length; ++i) {
        let laneLine = lineService.create(
          road.leftLanes[i].start,
          road.leftLanes[i].end
        );
        laneLine.setStyle(VectorStyle.SingleDashedLine);
      }
      for (let i = 0; i < road.rightLanes.length; ++i) {
        let laneLine = lineService.create(
          road.rightLanes[i].start,
          road.rightLanes[i].end
        );
        laneLine.setStyle(VectorStyle.SingleDashedLine);
      }
      lineService.create(
        road.midDivide.leftMidDivide.start,
        road.midDivide.leftMidDivide.end
      );
      lineService.create(
        road.midDivide.rightMidDivide.start,
        road.midDivide.rightMidDivide.end
      );
    }
  }

  // unlock(roadId) {
  //   let road = dataService.getRoad(roadId);
  //   let startPoint = dataService.getRoadPoint(road.startId);
  //   let endPoint = dataService.getRoadPoint(road.endId);
  //   let leftEdge = dataService.getRoadEdge(road.leftEdgeId);
  //   let rightEdge = dataService.getRoadEdge(road.rightEdgeId);
  //   let lanes = road.lanes;

  //   lineService.createLine(startPoint, endPoint);
  //   lineService.createLine(leftEdge.start, leftEdge.end);
  //   lineService.createLine(rightEdge.start, rightEdge.end);
  //   for (let i = 0; i < lanes.length; ++i) {
  //     lineService.createLine(lanes[i].start, lanes[i].end);
  //   }
  //   dataService.deleteRoad(roadId);
  // }
  /****************************************************************************************************************************************************************/
}

const roadService = new RoadService();
export { roadService };