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";
import bezierUtil from "./Util/bezierUtil.js";
import { elementService } from "./Service/ElementService";
import { coordinate } from "./Coordinate";
import { draw } from "./Renderer/Draw.js";

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

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

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

    this.modifyPoint = null;

    this.testStart = null;
    this.testEnd = null;
    this.testHit = false;
  }

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

    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, exceptCurveRoadId) {
    let info1 = this.getNearForRoad(position, exceptPointId, exceptRoadIds);
    let info2 = this.getNearForCurveRoad(
      position,
      exceptPointId,
      exceptCurveRoadId
    );

    this.getNearForControlPoint(position);
    let min1 = info1.min1;
    let modifyPoint = info1.modifyPoint;
    let _modifyPoint = info1._modifyPoint;

    if (min1 == null && info2.min1 != null) {
      min1 = info2.min1;
      modifyPoint = info2.modifyPoint;
      _modifyPoint = info2._modifyPoint;
    } else if (info2.min1 != null) {
      if (info1.min1.distance > info2.min1.distance) {
        min1 = info2.min1;
        modifyPoint = info2.modifyPoint;
        _modifyPoint = info2._modifyPoint;
      }
    }

    let min2 = info1.min2;
    if (min2 == null && info2.min2 != null) {
      min2 = info2.min2;
      modifyPoint = info2.modifyPoint;
      _modifyPoint = info2._modifyPoint;
    } else if (info2.min2 != null) {
      if (info1.min2.distance > info2.min2.distance) {
        min2 = info2.min2;
        modifyPoint = info2.modifyPoint;
        _modifyPoint = info2._modifyPoint;
      }
    }

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

    return result;
  }

  getNearForRoad(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);
      //垂直交点
      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,
            type: VectorType.RoadCorner,
          };

          //在公路内了
          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,
            type: VectorType.RoadCorner,
          };
          //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,
          type: VectorType.Road,
          roadId: roadId,
        };
      }

      if (_flag && mathUtil.getDistance(position, join) < road.width / 2) {
        _modifyPoint = join;
        _modifyPoint.linkedRoadId = roadId;
      }
    }

    return {
      min1: min1,
      min2: min2,
      modifyPoint: modifyPoint,
      _modifyPoint: _modifyPoint,
    };
  }

  //暂时只考虑端点
  getNearForCurveRoad(position, exceptPointId, exceptCurveRoadId) {
    let min1 = null; // 与墙角的距离
    let min2 = null; // 与墙面的距离
    // 纠正
    // 垂直，水平
    const modifyPoint = {};
    // 吸附在墙面上
    let _modifyPoint = null;
    const hasPointIds = [];
    if (exceptPointId) {
      hasPointIds.push(exceptPointId);
    }
    const curveRoads = dataService.getCurveRoads();
    for (const curveRoadId in curveRoads) {
      if (exceptCurveRoadId && exceptCurveRoadId == curveRoadId) {
        continue;
      }

      const curveRoad = dataService.getCurveRoad(curveRoadId);
      for (let i = 0; i < curveRoad.points.length; ++i) {
        let distance = null;
        //先找端点
        if (hasPointIds.indexOf(curveRoad.points[i].vectorId) == -1) {
          hasPointIds.push(curveRoad.points[i].vectorId);
          distance = mathUtil.getDistance(position, curveRoad.points[i]);

          if (distance < Constant.minAdsorbPix) {
            min1 = {
              distance: distance,
              pointId: curveRoad.points[i].vectorId,
              type: VectorType.CurveRoadCorner,
            };

            modifyPoint.linkedPointId = curveRoad.points[i].vectorId;
            modifyPoint.x = curveRoad.points[i].x;
            modifyPoint.y = curveRoad.points[i].y;
            delete modifyPoint.linkedPointIdX;
            delete modifyPoint.linkedPointIdY;
            break;
          }

          //start部分找到了与x接近的其他点
          if (
            Math.abs(position.x - curveRoad.points[i].x) < Constant.minAdsorbPix
          ) {
            if (!modifyPoint.linkedPointIdX) {
              modifyPoint.x = curveRoad.points[i].x;
              modifyPoint.linkedPointIdX = curveRoad.points[i].vectorId;
            } else {
              const linkedPointX = dataService.getCurvePoint(
                modifyPoint.linkedPointIdX
              );
              if (
                mathUtil.getDistance(position, linkedPointX) >
                mathUtil.getDistance(position, curveRoad.points[i])
              ) {
                modifyPoint.x = curveRoad.points[i].x;
                modifyPoint.linkedPointIdX = curveRoad.points[i].vectorId;
              }
            }
          }
          //start部分找到了与y接近的其他点
          if (
            Math.abs(position.y - curveRoad.points[i].y) < Constant.minAdsorbPix
          ) {
            if (!modifyPoint.linkedPointIdY) {
              modifyPoint.y = curveRoad.points[i].y;
              modifyPoint.linkedPointIdY = curveRoad.points[i].vectorId;
            } else {
              const linkedPointY = dataService.getCurvePoint(
                modifyPoint.linkedPointIdY
              );
              if (
                mathUtil.getDistance(position, linkedPointY) >
                mathUtil.getDistance(position, curveRoad.points[i])
              ) {
                modifyPoint.y = curveRoad.points[i].y;
                modifyPoint.linkedPointIdY = curveRoad.points[i].vectorId;
              }
            }
          }
        }
      }
    }
    return {
      min1: min1,
      min2: min2,
      modifyPoint: modifyPoint,
      _modifyPoint: _modifyPoint,
    };
  }

  getNearForControlPoint(position) {
    const controlPoints = dataService.getControlPoints();
    for (const key in controlPoints) {
      let controlPoint = controlPoints[key];
      let bezierData = [];
      let edge1 = dataService.getEdge(controlPoint.edgeInfo1.id);
      let start = edge1.getPosition(controlPoint.edgeInfo1.dir);
      let edge2 = dataService.getEdge(controlPoint.edgeInfo2.id);
      let end = edge2.getPosition(controlPoint.edgeInfo2.dir);

      start = coordinate.getScreenXY(start);
      let cp = coordinate.getScreenXY({
        x: controlPoint.x,
        y: controlPoint.y,
      });
      end = coordinate.getScreenXY(end);

      bezierData.push(start.x);
      bezierData.push(start.y);
      bezierData.push(cp.x);
      bezierData.push(cp.y);
      bezierData.push(end.x);
      bezierData.push(end.y);
      this.isHitForBezier(bezierData, coordinate.getScreenXY(position));
    }
  }

  updateSelectInfos(nearest, minDistance) {
    //console.log("实时监控：" + JSON.stringify(nearest));
    // 墙角状态是否改变
    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,
          type: nearest.minPoint.type,
          state: SelectState.Select,
        };
      } else {
        flag1 = this.isChanged(nearest.minPoint.pointId, null, 1);
        this.pointInfo = {
          pointId: nearest.minPoint.pointId,
          type: nearest.minPoint.type,
          state: null,
        };
      }
    } else {
      flag1 = this.isChanged(null, null, 1);
      this.pointInfo = {
        pointId: null,
        type: 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,
          type: nearest.minRoad.type,
          state: SelectState.Select,
        };
      } else {
        flag2 = this.isChanged(nearest.minRoad.roadId, null, 2);
        this.roadInfo = {
          roadId: nearest.minRoad.roadId,
          type: nearest.minRoad.type,
          state: null,
        };
      }
    } else {
      flag2 = this.isChanged(null, null, 2);
      this.roadInfo = {
        roadId: null,
        type: null,
        state: null,
      };
    }

    return flag1 || flag2;
  }

  // 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,
        this.pointInfo.type,
        SelectState.Select
      );
    } else if (this.roadInfo.roadId != null && this.roadInfo.state != null) {
      stateService.setSelectItem(
        this.roadInfo.roadId,
        this.roadInfo.type,
        SelectState.Select
      );
    } else {
      stateService.clearSelectItem();
    }
  }

  // getNearForCurveRoad(position, exceptPointId, exceptRoadIds) {
  //   let min1 = null;
  //   let min2 = null;
  //   const modifyPoint = {};
  //   const hasPointIds = [];
  //   if (exceptPointId) {
  //     hasPointIds.push(exceptPointId);
  //   }
  //   const curveRoads = dataService.getCurveRoads();
  //   for (const curveRoadId in curveRoads) {
  //     if (exceptRoadIds && exceptRoadIds.hasOwnProperty(curveRoadId)) {
  //       continue;
  //     }

  //     const curveRoad = dataService.getCurveRoad(curveRoadId);
  //     const startPoint = dataService.getPoint(curveRoad.startId);
  //     const endPoint = dataService.getPoint(curveRoad.endId);
  //     let distance = null;

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

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

  //         if (min1.distance < Constant.minAdsorbPix) {
  //           modifyPoint.linkedPointId = curveRoad.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 = curveRoad.startId;
  //         } else {
  //           const linkedPointX = dataService.getPoint(
  //             modifyPoint.linkedPointIdX
  //           );
  //           if (
  //             mathUtil.getDistance(position, linkedPointX) >
  //             mathUtil.getDistance(position, startPoint)
  //           ) {
  //             modifyPoint.x = startPoint.x;
  //             modifyPoint.linkedPointIdX = curveRoad.startId;
  //           }
  //         }
  //       }
  //       //start部分找到了与y接近的其他点
  //       if (Math.abs(position.y - startPoint.y) < Constant.minAdsorbPix) {
  //         if (!modifyPoint.linkedPointIdY) {
  //           modifyPoint.y = startPoint.y;
  //           modifyPoint.linkedPointIdY = curveRoad.startId;
  //         } else {
  //           const linkedPointY = dataService.getPoint(
  //             modifyPoint.linkedPointIdY
  //           );
  //           if (
  //             mathUtil.getDistance(position, linkedPointY) >
  //             mathUtil.getDistance(position, startPoint)
  //           ) {
  //             modifyPoint.y = startPoint.y;
  //             modifyPoint.linkedPointIdY = curveRoad.startId;
  //           }
  //         }
  //       }
  //     }

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

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

  //   const result = {
  //     minPoint: min1,
  //     tagInfo: {},
  //   };

  //   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;
  //   }
  //   return result;
  // }

  isHitForBezier(bezierData, position) {
    const { isHit, getInfo } = bezierUtil.measureBezier(...bezierData);
    let flag = isHit(position.x, position.y, Constant.minAdsorbPix);
    const { point } = getInfo(position);

    this.testStart = position;
    this.testEnd = {
      x: point[0],
      y: point[1],
    };
    this.testHit = flag;
  }

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

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

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