traffic-laser/src/graphic/History/HistoryUtil.js

import { mathUtil } from "../Util/MathUtil";
import { dataService } from "../Service/DataService";
import { textService } from "../Service/TextService";
import Constant from "../Constant";
import Settings from "../Settings";

export default class HistoryUtil {
  constructor() {}

  isDifferentForPoints(point1, point2) {
    if (
      point1.x == point2.x &&
      point1.y == point2.y &&
      mathUtil.equalJSON(point1.parent, point1.parent) &&
      point1.category == point2.category &&
      point1.locationMode == point2.locationMode &&
      point1.linkedBasePointId == point2.linkedBasePointId &&
      point1.linkedTestPointId == point2.linkedTestPointId
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForLines(line1, line2) {
    if (
      line1.startId == line2.startId &&
      line1.endId == line2.endId &&
      line1.category == line2.category &&
      line1.locationMode == line2.locationMode
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForCurvePoints(curvePoint1, curvePoint2) {
    if (
      curvePoint1.x == curvePoint2.x &&
      curvePoint1.y == curvePoint2.y &&
      curvePoint1.parent == curvePoint2.parent &&
      curvePoint1.index == curvePoint2.index
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForCurveLines(curveLine1, curveLine2) {
    if (
      curveLine1.startId == curveLine2.startId &&
      curveLine1.endId == curveLine2.endId &&
      mathUtil.equalJSON(curveLine1.points, curveLine2.points)
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForCircles(circle1, circle2) {
    if (
      mathUtil.equalPoint(circle1.center, circle2.center) &&
      circle1.radiusX == circle2.radiusX &&
      circle1.radiusY == circle2.radiusY &&
      circle1.color == circle2.color
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForTexts(text1, text2) {
    if (
      mathUtil.equalPoint(text1.center, text2.center) &&
      text1.value == text2.value &&
      text1.angle == text2.angle
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForMagnifiers(magnifier1, magnifier2) {
    if (
      mathUtil.equalPoint(magnifier1.position, magnifier2.position) &&
      magnifier1.photoUrl == magnifier2.photoUrl
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForSVGs(svg1, svg2) {
    if (
      mathUtil.equalPoint(svg1.center, svg2.center) &&
      svg1.type == svg2.type &&
      svg1.angle == svg2.angle &&
      svg1.scale == svg2.scale
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForRoadPoints(roadPoint1, roadPoint2) {
    if (
      mathUtil.equalPoint(roadPoint1, roadPoint2) &&
      mathUtil.equalJSON(roadPoint1.parent, roadPoint2.parent)
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForRoadEdges(roadEdge1, roadEdge2) {
    if (
      mathUtil.equalPoint(roadEdge1.start, roadEdge2.start) &&
      mathUtil.equalPoint(roadEdge1.end, roadEdge2.end) &&
      roadEdge1.parent == roadEdge2.parent &&
      roadEdge1.style == roadEdge2.style
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForRoads(road1, road2) {
    if (
      road1.startId == road2.startId &&
      road1.endId == road2.endId &&
      road1.leftEdgeId == road2.leftEdgeId &&
      road1.rightEdgeId == road2.rightEdgeId &&
      road1.way == road2.way
    ) {
      if (road1.way == Constant.oneWay) {
        if (
          road1.singleRoadWidth == road2.singleRoadWidth &&
          road1.singleRoadDrivewayCount == road2.singleRoadDrivewayCount &&
          road1.singleLanes.length == road2.singleLanes.length
        ) {
          for (let i = 0; i < road1.singleLanes.length; ++i) {
            if (
              !mathUtil.equalPoint(
                road1.singleLanes[i].start,
                road2.singleLanes[i].start
              ) ||
              !mathUtil.equalPoint(
                road1.singleLanes[i].end,
                road2.singleLanes[i].end
              )
            ) {
              return true;
            }
          }
          return false;
        } else {
          return true;
        }
      } else if (road1.way == Constant.twoWay) {
        if (
          road1.leftWidth == road2.leftWidth &&
          road1.rightWidth == road2.rightWidth &&
          road1.leftDrivewayCount == road2.leftDrivewayCount &&
          road1.rightDrivewayCount == road2.rightDrivewayCount &&
          road1.midDivide.midDivideWidth == road2.midDivide.midDivideWidth &&
          mathUtil.clonePoint(
            road1.midDivide.leftMidDivide.start,
            road2.midDivide.leftMidDivide.start
          ) &&
          mathUtil.clonePoint(
            road1.midDivide.leftMidDivide.end,
            road2.midDivide.leftMidDivide.end
          ) &&
          mathUtil.clonePoint(
            road1.midDivide.rightMidDivide.start,
            road2.midDivide.rightMidDivide.start
          ) &&
          mathUtil.clonePoint(
            road1.midDivide.rightMidDivide.end,
            road2.midDivide.rightMidDivide.end
          ) &&
          road1.leftLanes.length == road2.leftLanes.length &&
          road1.rightLanes.length == road2.rightLanes.length
        ) {
          for (let i = 0; i < road1.leftLanes.length; ++i) {
            if (
              !mathUtil.equalPoint(
                road1.leftLanes[i].start,
                road2.leftLanes[i].start
              ) ||
              !mathUtil.equalPoint(
                road1.leftLanes[i].end,
                road2.leftLanes[i].end
              )
            ) {
              return true;
            }
          }
          for (let i = 0; i < road1.rightLanes.length; ++i) {
            if (
              !mathUtil.equalPoint(
                road1.rightLanes[i].start,
                road2.rightLanes[i].start
              ) ||
              !mathUtil.equalPoint(
                road1.rightLanes[i].end,
                road2.rightLanes[i].end
              )
            ) {
              return true;
            }
          }
          return false;
        } else {
          return true;
        }
      } else {
        return true;
      }
    } else {
      return true;
    }
  }

  isDifferentForCurveRoadPoints(curveRoadPoint1, curveRoadPoint2) {
    if (
      mathUtil.equalPoint(curveRoadPoint1, curveRoadPoint2) &&
      mathUtil.equalJSON(curveRoadPoint1.parent, curveRoadPoint2.parent) &&
      curveRoadPoint1.index == curveRoadPoint2.index
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForCurveRoadEdges(curveRoadEdge1, curveRoadEdge2) {
    if (
      mathUtil.equalPoint(curveRoadEdge1.start, curveRoadEdge2.start) &&
      mathUtil.equalPoint(curveRoadEdge1.end, curveRoadEdge2.end) &&
      mathUtil.equalPoints(curveRoadEdge1.points, curveRoadEdge2.points) &&
      curveRoadEdge1.parent == curveRoadEdge2.parent &&
      curveRoadEdge1.style == curveRoadEdge2.style
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForCurveRoads(curveRoad1, curveRoad2) {
    if (
      curveRoad1.startId == curveRoad2.startId &&
      curveRoad1.endId == curveRoad2.endId &&
      mathUtil.equalPoints(curveRoad1.points, curveRoad2.points) &&
      curveRoad1.leftEdgeId == curveRoad2.leftEdgeId &&
      curveRoad1.rightEdgeId == curveRoad2.rightEdgeId &&
      curveRoad1.way == curveRoad2.way
    ) {
      if (curveRoad1.way == Constant.oneWay) {
        if (
          curveRoad1.singleRoadWidth == curveRoad2.singleRoadWidth &&
          curveRoad1.singleRoadDrivewayCount ==
            curveRoad2.singleRoadDrivewayCount
        ) {
          return false;
        } else {
          return true;
        }
      } else if (curveRoad1.way == Constant.twoWay) {
        if (
          curveRoad1.leftWidth == curveRoad2.leftWidth &&
          curveRoad1.rightWidth == curveRoad2.rightWidth &&
          curveRoad1.leftDrivewayCount == curveRoad2.leftDrivewayCount &&
          curveRoad1.rightDrivewayCount == curveRoad2.rightDrivewayCount &&
          curveRoad1.midDivide.midDivideWidth ==
            curveRoad2.midDivide.midDivideWidth
        ) {
          return false;
        } else {
          return true;
        }
      } else {
        return true;
      }
    } else {
      return true;
    }
  }

  isDifferentForCrossPoints(crossPoint1, crossPoint2) {
    if (
      mathUtil.equalPoint(crossPoint1, crossPoint2) &&
      mathUtil.equalPoint(crossPoint1.extremePoint, crossPoint2.extremePoint) &&
      crossPoint1.edgeInfo1.id == crossPoint2.edgeInfo1.id &&
      crossPoint1.edgeInfo1.dir == crossPoint2.edgeInfo1.dir &&
      crossPoint1.edgeInfo2.id == crossPoint2.edgeInfo2.id &&
      crossPoint1.edgeInfo2.dir == crossPoint2.edgeInfo2.dir
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForSettings(settings1, settings2) {
    if (
      settings1.selectLineCategory == settings2.selectLineCategory &&
      settings1.selectPointCategory == settings2.selectPointCategory &&
      settings1.selectLocationMode == settings2.selectLocationMode &&
      settings1.baseLineId == settings2.baseLineId &&
      settings1.selectBasePointId == settings2.selectBasePointId
    ) {
      return false;
    } else {
      return true;
    }
  }

  assignPointFromPoint(point1, point2) {
    const pointInfo = {};
    pointInfo.vectorId = point1.vectorId;
    pointInfo.position = { x: point2.x, y: point2.y };
    pointInfo.parent = JSON.parse(JSON.stringify(point2.parent));
    pointInfo.locationMode = point2.locationMode;
    pointInfo.linkedBasePointId = point2.linkedBasePointId;
    pointInfo.linkedTestPointId = point2.linkedTestPointId;
    pointInfo.category = point2.category;
    this.setPointInfo(pointInfo);
  }

  assignLineFromLine(line1, line2) {
    const lineInfo = {};
    lineInfo.vectorId = line1.vectorId;
    lineInfo.start = line2.start;
    lineInfo.end = line2.end;
    lineInfo.category = line2.category;
    lineInfo.locationMode = line2.locationMode;
    lineInfo.value = line2.value;
    this.setLineInfo(lineInfo);
  }

  assignCurvePointFromCurvePoint(curvePoint1, curvePoint2) {
    const curvePointInfo = {};
    curvePointInfo.vectorId = curvePoint1.vectorId;
    curvePointInfo.position = { x: curvePoint2.x, y: curvePoint2.y };
    curvePointInfo.parent = curvePoint2.parent;
    curvePointInfo.index = curvePoint2.index;
    this.setCurvePointInfo(curvePointInfo);
  }

  assignCurveLineFromCurveLine(curveLine1, curveLine2) {
    const curveLineInfo = {};
    curveLineInfo.vectorId = curveLine1.vectorId;
    curveLineInfo.startId = curveLine2.startId;
    curveLineInfo.endId = curveLine2.endId;
    curveLineInfo.points = JSON.parse(JSON.stringify(curveLine2.points));
    curveLineInfo.curves = JSON.parse(JSON.stringify(curveLine2.curves));
    this.setCurveLineInfo(curveLineInfo);
  }

  assignCircleFromCircle(circle1, circle2) {
    const circleInfo = {};
    circleInfo.vectorId = circle1.vectorId;
    circleInfo.center = circle2.center;
    circleInfo.radiusX = circle2.radiusX;
    circleInfo.radiusY = circle2.radiusY;
    circleInfo.points = JSON.parse(JSON.stringify(circle2.points));
    circleInfo.color = circle2.color;
    this.setCircleInfo(circleInfo);
  }

  assignTextFromText(text1, text2) {
    const textInfo = {};
    textInfo.vectorId = text1.vectorId;
    textInfo.value = text2.value;
    textInfo.center = JSON.parse(JSON.stringify(text2.center));
    textInfo.angle = text2.angle;
    this.setTextInfo(textInfo);
  }

  assignMagnifierFromMagnifier(magnifier1, magnifier2) {
    const magnifierInfo = {};
    magnifierInfo.vectorId = magnifier1.vectorId;
    magnifierInfo.photoUrl = magnifier2.photoUrl;
    magnifierInfo.position = JSON.parse(JSON.stringify(magnifier2.position));
    magnifierInfo.popPosition = JSON.parse(
      JSON.stringify(magnifier2.popPosition)
    );
    this.setMagnifierInfo(magnifierInfo);
  }

  assignSVGFromSVG(svg1, svg2) {
    const svgInfo = {};
    svgInfo.vectorId = svg1.vectorId;
    svgInfo.type = svg2.type;
    svgInfo.center = JSON.parse(JSON.stringify(svg2.center));
    svgInfo.points = JSON.parse(JSON.stringify(svg2.points));
    svgInfo.angle = svg2.angle;
    svgInfo.scale = svg2.scale;
    this.setSVGInfo(svgInfo);
  }

  assignRoadPointFromRoadPoint(roadPoint1, roadPoint2) {
    const roadPointInfo = {};
    roadPointInfo.vectorId = roadPoint1.vectorId;
    roadPointInfo.position = {
      x: roadPoint2.position.x,
      y: roadPoint2.position.y,
    };
    roadPointInfo.parent = JSON.parse(JSON.stringify(roadPoint2.parent));
    this.setRoadPointInfo(roadPointInfo);
  }

  assignRoadEdgeFromRoadEdge(roadEdge1, roadEdge2) {
    const roadEdgeInfo = {};
    roadEdgeInfo.vectorId = roadEdge1.vectorId;
    roadEdgeInfo.style = roadEdge2.style;
    roadEdgeInfo.start = { x: roadEdge2.start.x, y: roadEdge2.start.y };
    roadEdgeInfo.end = { x: roadEdge2.end.x, y: roadEdge2.end.y };
    roadEdgeInfo.parent = roadEdge2.parent;
    this.setRoadEdgeInfo(roadEdgeInfo);
  }

  assignRoadFromRoad(road1, road2) {
    const roadInfo = {};
    roadInfo.vectorId = road1.vectorId;
    roadInfo.startId = road2.startId;
    roadInfo.endId = road2.endId;
    roadInfo.leftEdgeId = road2.leftEdgeId;
    roadInfo.rightEdgeId = road2.rightEdgeId;
    roadInfo.way = road2.way;
    if (road2.way == Constant.oneWay) {
      roadInfo.singleRoadWidth = road2.singleRoadWidth;
      roadInfo.singleRoadDrivewayCount = road2.singleRoadDrivewayCount;
      roadInfo.singleLanes = JSON.parse(JSON.stringify(road2.singleLanes));
    } else if (road2.way == Constant.twoWay) {
      roadInfo.leftWidth = road2.leftWidth;
      roadInfo.rightWidth = road2.rightWidth;
      roadInfo.leftDrivewayCount = road2.leftDrivewayCount;
      roadInfo.rightDrivewayCount = road2.rightDrivewayCount;
      roadInfo.midDivide = JSON.parse(JSON.stringify(road2.midDivide));
      roadInfo.leftLanes = JSON.parse(JSON.stringify(road2.leftLanes));
      roadInfo.rightLanes = JSON.parse(JSON.stringify(road2.rightLanes));
    }
    this.setRoadInfo(roadInfo);
  }

  assignCurveRoadPointFromCurveRoadPoint(curveRoadPoint1, curveRoadPoint2) {
    const curveRoadPointInfo = {};
    curveRoadPointInfo.vectorId = curveRoadPoint1.vectorId;
    curveRoadPointInfo.position = {
      x: curveRoadPoint2.position.x,
      y: curveRoadPoint2.position.y,
    };
    curveRoadPointInfo.parent = JSON.parse(
      JSON.stringify(curveRoadPoint2.parent)
    );

    curveRoadPointInfo.index = curveRoadPoint2.index;
    this.setCurveRoadPointInfo(curveRoadPointInfo);
  }

  assignCurveRoadEdgeFromCurveRoadEdge(curveRoadEdge1, curveRoadEdge2) {
    const curveRoadEdgeInfo = {};
    curveRoadEdgeInfo.vectorId = curveRoadEdge1.vectorId;
    curveRoadEdgeInfo.start = {
      x: curveRoadEdge2.start.x,
      y: curveRoadEdge2.start.y,
    };
    curveRoadEdgeInfo.end = {
      x: curveRoadEdge2.end.x,
      y: curveRoadEdge2.end.y,
    };
    curveRoadEdgeInfo.points = JSON.parse(
      JSON.stringify(curveRoadEdge2.points)
    );
    curveRoadEdgeInfo.curves = JSON.parse(
      JSON.stringify(curveRoadEdge2.curves)
    );
    curveRoadEdgeInfo.parent = curveRoadEdge2.parent;
    curveRoadEdgeInfo.style = curveRoadEdge2.style;
    this.setCurveRoadEdgeInfo(curveRoadEdgeInfo);
  }

  assignCurveRoadFromCurveRoad(curveRoad1, curveRoad2) {
    const curveRoadInfo = {};
    curveRoadInfo.vectorId = curveRoad1.vectorId;
    curveRoadInfo.startId = curveRoad2.startId;
    curveRoadInfo.endId = curveRoad2.endId;
    curveRoadInfo.leftEdgeId = curveRoad2.leftEdgeId;
    curveRoadInfo.rightEdgeId = curveRoad2.rightEdgeId;
    curveRoadInfo.points = JSON.parse(JSON.stringify(curveRoad2.points));
    curveRoadInfo.curves = JSON.parse(JSON.stringify(curveRoad2.curves));
    curveRoadInfo.way = curveRoad2.way;
    if (curveRoad2.way == Constant.oneWay) {
      curveRoadInfo.singleCurveRoadWidth = curveRoad2.singleCurveRoadWidth;
      curveRoadInfo.singleCurveRoadDrivewayCount =
        curveRoad2.singleCurveRoadDrivewayCount;
      curveRoadInfo.singleLanesCurves = JSON.parse(
        JSON.stringify(curveRoad2.singleLanesCurves)
      );
    } else if (curveRoad2.way == Constant.twoWay) {
      curveRoadInfo.leftWidth = curveRoad2.leftWidth;
      curveRoadInfo.rightWidth = curveRoad2.rightWidth;
      curveRoadInfo.leftDrivewayCount = curveRoad2.leftDrivewayCount;
      curveRoadInfo.rightDrivewayCount = curveRoad2.rightDrivewayCount;
      curveRoadInfo.midDivide = JSON.parse(
        JSON.stringify(curveRoad2.midDivide)
      );
      curveRoadInfo.leftLanesCurves = JSON.parse(
        JSON.stringify(curveRoad2.leftLanesCurves)
      );
      curveRoadInfo.rightLanesCurves = JSON.parse(
        JSON.stringify(curveRoad2.rightLanesCurves)
      );
    }
    curveRoadInfo.points = [];
    for (let i = 0; i < curveRoad2.points.length; ++i) {
      curveRoadInfo.points[i] = {};
      // curveRoadInfo.points[i].vectorId = curveRoad2.points[i].vectorId;
      curveRoadInfo.points[i] = curveRoad2.points[i];
    }
    this.setCurveRoadInfo(curveRoadInfo);
  }

  assignCrossPointFromCrossPoint(crossPoint1, crossPoint2) {
    const crossPointInfo = {};
    crossPointInfo.vectorId = crossPoint1.vectorId;
    crossPointInfo.position = {
      x: crossPoint2.position.x,
      y: crossPoint2.position.y,
    };
    crossPointInfo.edgeInfo1 = JSON.parse(
      JSON.stringify(crossPoint2.edgeInfo1)
    );
    crossPointInfo.edgeInfo2 = JSON.parse(
      JSON.stringify(crossPoint2.edgeInfo2)
    );
    crossPoint1.edgeInfo1 = JSON.parse(JSON.stringify(crossPoint2.edgeInfo1));
    crossPoint1.edgeInfo2 = JSON.parse(JSON.stringify(crossPoint2.edgeInfo2));
    dataService.addCrossPoint(crossPoint1);
    crossPointInfo.extremePoint = {
      x: crossPoint2.extremePoint.x,
      y: crossPoint2.extremePoint.y,
    };
    crossPointInfo.curves = JSON.parse(JSON.stringify(crossPoint2.curves));
    this.setCrossPointInfo(crossPointInfo);
  }

  assignSettingsFromSettings(settings1, settings2) {
    settings1.selectLineCategory = settings2.selectLineCategory;
    settings1.selectPointCategory = settings2.selectPointCategory;
    settings1.selectLocationMode = settings2.selectLocationMode;
    settings1.baseLineId = settings2.baseLineId;
    settings1.selectBasePointId = settings2.selectBasePointId;
  }

  getDataForPoint(point) {
    const data = {};
    data.id = point.vectorId;
    mathUtil.clonePoint(data, point);
    data.parent = JSON.parse(JSON.stringify(point.parent));
    data.category = point.category;
    data.locationMode = point.locationMode;
    data.linkedBasePointId = point.linkedBasePointId;
    data.linkedTestPointId = point.linkedTestPointId;
    data.type = point.geoType;
    return data;
  }

  getDataForLine(line) {
    const data = {};
    data.id = line.vectorId;
    data.start = line.startId;
    data.end = line.endId;
    data.category = line.category;
    data.locationMode = line.locationMode;
    data.type = line.geoType;
    return data;
  }

  getDataForCurvePoint(curvePoint) {
    const data = {};
    data.id = curvePoint.vectorId;
    mathUtil.clonePoint(data, curvePoint);
    data.parent = curvePoint.parent;
    data.index = curvePoint.index;
    data.type = curvePoint.geoType;
    return data;
  }

  getDataForCurveLine(curveLine) {
    const data = {};
    data.id = curveLine.vectorId;
    data.startId = curveLine.startId;
    data.endId = curveLine.endId;
    data.points = JSON.parse(JSON.stringify(curveLine.points));
    data.curves = JSON.parse(JSON.stringify(curveLine.curves));
    data.type = curveLine.geoType;
    return data;
  }

  getDataForCircle(circle) {
    const data = {};
    data.id = circle.vectorId;
    data.center = {};
    mathUtil.clonePoint(data.center, circle.center);
    data.radiusX = circle.radiusX;
    data.radiusY = circle.radiusY;
    data.points = circle.points;
    data.color = circle.color;
    data.type = circle.geoType;
    return data;
  }

  getDataForText(text) {
    const data = {};
    data.id = text.vectorId;
    data.type = text.geoType;
    data.angle = text.angle;
    data.center = {};
    mathUtil.clonePoint(data.center, text.center);
    data.value = text.value;
    return data;
  }

  getDataForMagnifier(magnifier) {
    const data = {};
    data.id = magnifier.vectorId;
    data.type = magnifier.geoType;
    data.position = {};
    data.popPosition = {};
    mathUtil.clonePoint(data.position, magnifier.position);
    mathUtil.clonePoint(data.popPosition, magnifier.popPosition);
    data.photoUrl = magnifier.photoUrl;
    return data;
  }

  getDataForSVG(svg) {
    const data = {};
    data.id = svg.vectorId;
    data.type = svg.geoType;
    data.center = {};
    mathUtil.clonePoint(data.center, svg.center);
    data.points = [];
    data.points[0] = {};
    mathUtil.clonePoint(data.points[0], svg.points[0]);
    data.points[1] = {};
    mathUtil.clonePoint(data.points[1], svg.points[1]);
    data.points[2] = {};
    mathUtil.clonePoint(data.points[2], svg.points[2]);
    data.points[3] = {};
    mathUtil.clonePoint(data.points[3], svg.points[3]);
    data.type = svg.type;
    data.angle = svg.angle;
    data.scale = svg.scale;
    return data;
  }

  getDataForRoadPoint(roadPoint) {
    const data = {};
    data.id = roadPoint.vectorId;
    data.type = roadPoint.geoType;
    data.position = {};
    mathUtil.clonePoint(data.position, roadPoint);
    data.parent = JSON.parse(JSON.stringify(roadPoint.parent));
    return data;
  }

  getDataForRoadEdge(roadEdge) {
    const data = {};
    data.id = roadEdge.vectorId;
    data.type = roadEdge.geoType;
    data.parent = roadEdge.parent;
    data.start = {};
    data.start = JSON.parse(JSON.stringify(roadEdge.start));
    data.end = {};
    data.end = JSON.parse(JSON.stringify(roadEdge.end));
    return data;
  }

  getDataForRoad(road) {
    const data = {};
    data.id = road.vectorId;
    data.type = road.geoType;
    data.startId = road.startId;
    data.endId = road.endId;
    data.leftEdgeId = road.leftEdgeId;
    data.rightEdgeId = road.rightEdgeId;
    data.way = road.way;
    if (road.way == Constant.oneWay) {
      data.singleRoadWidth = road.singleRoadWidth;
      data.singleRoadDrivewayCount = road.singleRoadDrivewayCount;
      data.singleLanes = JSON.parse(JSON.stringify(road.singleLanes));
    } else if (road.way == Constant.twoWay) {
      data.leftWidth = road.leftWidth;
      data.rightWidth = road.rightWidth;
      data.leftDrivewayCount = road.leftDrivewayCount;
      data.rightDrivewayCount = road.rightDrivewayCount;
      data.midDivide = JSON.parse(JSON.stringify(road.midDivide));
      data.leftLanes = JSON.parse(JSON.stringify(road.leftLanes));
      data.rightLanes = JSON.parse(JSON.stringify(road.rightLanes));
    }
    return data;
  }

  getDataForCurveRoadPoint(curveRoadPoint) {
    const data = {};
    data.id = curveRoadPoint.vectorId;
    data.type = curveRoadPoint.geoType;
    data.position = {};
    mathUtil.clonePoint(data.position, curveRoadPoint);
    data.parent = curveRoadPoint.parent;
    data.index = curveRoadPoint.index;
    return data;
  }

  getDataForCurveRoadEdge(curveRoadEdge) {
    const data = {};
    data.id = curveRoadEdge.vectorId;
    data.type = curveRoadEdge.geoType;
    data.parent = curveRoadEdge.parent;
    data.start = JSON.parse(JSON.stringify(curveRoadEdge.start));
    data.end = JSON.parse(JSON.stringify(curveRoadEdge.end));
    data.points = JSON.parse(JSON.stringify(curveRoadEdge.points));
    data.curves = JSON.parse(JSON.stringify(curveRoadEdge.curves));
    return data;
  }

  getDataForCurveRoad(curveRoad) {
    const data = {};
    data.id = curveRoad.vectorId;
    data.type = curveRoad.geoType;
    data.startId = curveRoad.startId;
    data.endId = curveRoad.endId;
    data.leftEdgeId = curveRoad.leftEdgeId;
    data.rightEdgeId = curveRoad.rightEdgeId;
    data.points = JSON.parse(JSON.stringify(curveRoad.points));
    data.curves = JSON.parse(JSON.stringify(curveRoad.curves));
    data.way = curveRoad.way;
    if (curveRoad.way == Constant.oneWay) {
      data.singleCurveRoadWidth = curveRoad.singleRoadWidth;
      data.singleCurveRoadDrivewayCount = curveRoad.singleRoadDrivewayCount;
      data.singleLanesCurves = JSON.parse(
        JSON.stringify(curveRoad.singleLanesCurves)
      );
    } else if (curveRoad.way == Constant.twoWay) {
      data.leftWidth = curveRoad.leftWidth;
      data.rightWidth = curveRoad.rightWidth;
      data.leftDrivewayCount = curveRoad.leftDrivewayCount;
      data.rightDrivewayCount = curveRoad.rightDrivewayCount;
      data.midDivide = JSON.parse(JSON.stringify(curveRoad.midDivide));
      data.leftLanesCurves = JSON.parse(
        JSON.stringify(curveRoad.leftLanesCurves)
      );
      data.rightLanesCurves = JSON.parse(
        JSON.stringify(curveRoad.rightLanesCurves)
      );
    }
    return data;
  }

  getDataForCrossPoint(crossPoint) {
    const data = {};
    data.id = crossPoint.vectorId;
    data.type = crossPoint.geoType;
    data.position = {};
    mathUtil.clonePoint(data.position, crossPoint);
    data.extremePoint = {};
    mathUtil.clonePoint(data.extremePoint, crossPoint.extremePoint);

    data.edgeInfo1 = JSON.parse(JSON.stringify(crossPoint.edgeInfo1));
    data.edgeInfo2 = JSON.parse(JSON.stringify(crossPoint.edgeInfo2));
    data.curves = JSON.parse(JSON.stringify(crossPoint.curves));
    return data;
  }

  getDataForSettings(settings) {
    const data = {};
    data.selectLineCategory = settings.selectLineCategory;
    data.selectPointCategory = settings.selectPointCategory;
    data.selectLocationMode = settings.selectLocationMode;
    data.baseLineId = settings.baseLineId;
    data.selectBasePointId = settings.selectBasePointId;
    return data;
  }

  setPointInfo(pointInfo) {
    let point = dataService.getPoint(pointInfo.vectorId);
    mathUtil.clonePoint(point, pointInfo.position);
    point.parent = JSON.parse(JSON.stringify(pointInfo.parent));
    point.category = pointInfo.category;
    point.locationMode = pointInfo.locationMode;
    point.linkedBasePointId = pointInfo.linkedBasePointId;
    point.linkedTestPointId = pointInfo.linkedTestPointId;
    return point;
  }

  setLineInfo(lineInfo) {
    let line = dataService.getLine(lineInfo.vectorId);
    line.startId = lineInfo.start;
    line.endId = lineInfo.end;
    line.category = lineInfo.category;
    line.locationMode = lineInfo.locationMode;
    line.value = lineInfo.value;
    return line;
  }

  setCurvePointInfo(curvePointInfo) {
    let curvePoint = dataService.getCurvePoint(curvePointInfo.vectorId);
    mathUtil.clonePoint(curvePoint, curvePointInfo.position);
    curvePoint.parent = curvePointInfo.parent;
    curvePoint.index = curvePointInfo.index;
    return curvePoint;
  }

  setCurveLineInfo(curveLineInfo) {
    let curveLine = dataService.getCurveLine(curveLineInfo.vectorId);
    curveLine.startId = curveLineInfo.start;
    curveLine.endId = curveLineInfo.end;
    for (let i = 0; i < curveLineInfo.points.length; ++i) {
      curveLine.points[i] = dataService.getCurvePoint(
        curveLineInfo.points[i].vectorId
      );
    }
    curveLine.curves = JSON.parse(JSON.stringify(curveLineInfo.curves));
    return curveLine;
  }

  setCircleInfo(circleInfo) {
    let circle = dataService.getCircle(circleInfo.vectorId);
    circle.center = circleInfo.center;
    circle.radius = circleInfo.radius;
    circle.color = circleInfo.color;
    circle.points = circleInfo.points;
    return circle;
  }

  setTextInfo(textInfo) {
    let text = dataService.getText(textInfo.vectorId);
    text.vectorId = textInfo.vectorId;
    text.center = JSON.parse(JSON.stringify(textInfo.center));
    text.value = textInfo.value;
    text.angle = textInfo.angle;
  }

  setMagnifierInfo(magnifierInfo) {
    let magnifier = dataService.getMagnifier(magnifierInfo.vectorId);
    magnifier.vectorId = magnifierInfo.vectorId;
    magnifier.position = JSON.parse(JSON.stringify(magnifierInfo.position));
    magnifier.popPosition = JSON.parse(
      JSON.stringify(magnifierInfo.popPosition)
    );
    magnifier.photoUrl = magnifierInfo.photoUrl;
  }

  setSVGInfo(svgInfo) {
    let svg = dataService.getSVG(svgInfo.vectorId);
    svg.vectorId = svgInfo.vectorId;
    svg.center = JSON.parse(JSON.stringify(svgInfo.center));
    svg.points = JSON.parse(JSON.stringify(svgInfo.points));
    svg.type = svgInfo.type;
    svg.angle = svgInfo.angle;
    svg.scale = svgInfo.scale;
  }

  setRoadPointInfo(roadPointInfo) {
    let roadPoint = dataService.getRoadPoint(roadPointInfo.vectorId);
    roadPoint.vectorId = roadPointInfo.vectorId;
    mathUtil.clonePoint(roadPoint, roadPointInfo.position);
    roadPoint.parent = JSON.parse(JSON.stringify(roadPointInfo.parent));
  }

  setRoadEdgeInfo(roadEdgeInfo) {
    let roadEdge = dataService.getRoadEdge(roadEdgeInfo.vectorId);
    roadEdge.vectorId = roadEdgeInfo.vectorId;
    mathUtil.clonePoint(roadEdge.start, roadEdgeInfo.start);
    mathUtil.clonePoint(roadEdge.end, roadEdgeInfo.end);
    roadEdge.type = roadEdgeInfo.type;
    roadEdge.style = roadEdgeInfo.style;
  }

  setRoadInfo(roadInfo) {
    let road = dataService.getRoad(roadInfo.vectorId);
    road.vectorId = roadInfo.vectorId;
    road.startId = roadInfo.startId;
    road.endId = roadInfo.endId;
    road.leftEdgeId = roadInfo.leftEdgeId;
    road.rightEdgeId = roadInfo.rightEdgeId;
    road.way = roadInfo.way;
    if (road.way == Constant.oneWay) {
      road.singleRoadWidth = roadInfo.singleRoadWidth;
      road.singleRoadDrivewayCount = roadInfo.singleRoadDrivewayCount;
      road.singleLanes = JSON.parse(JSON.stringify(roadInfo.singleLanes));
    } else if (road.way == Constant.twoWay) {
      road.leftWidth = roadInfo.leftWidth;
      road.rightWidth = roadInfo.rightWidth;
      road.leftDrivewayCount = roadInfo.leftDrivewayCount;
      road.rightDrivewayCount = roadInfo.rightDrivewayCount;
      road.midDivide = JSON.parse(JSON.stringify(roadInfo.midDivide));
      road.leftLanes = JSON.parse(JSON.stringify(roadInfo.leftLanes));
      road.rightLanes = JSON.parse(JSON.stringify(roadInfo.rightLanes));
    }
  }

  setCurveRoadPointInfo(curveRoadPointInfo) {
    let curveRoadPoint = dataService.getCurveRoadPoint(
      curveRoadPointInfo.vectorId
    );
    curveRoadPoint.vectorId = curveRoadPointInfo.vectorId;
    mathUtil.clonePoint(curveRoadPoint, curveRoadPointInfo.position);
    curveRoadPoint.parent = JSON.parse(
      JSON.stringify(curveRoadPointInfo.parent)
    );
    curveRoadPoint.index = curveRoadPointInfo.index;
  }

  setCurveRoadEdgeInfo(curveRoadEdgeInfo) {
    let curveRoadEdge = dataService.getCurveRoadEdge(
      curveRoadEdgeInfo.vectorId
    );
    curveRoadEdge.vectorId = curveRoadEdgeInfo.vectorId;
    mathUtil.clonePoint(curveRoadEdge.start, curveRoadEdgeInfo.start);
    mathUtil.clonePoint(curveRoadEdge.end, curveRoadEdgeInfo.end);
    mathUtil.clonePoints(curveRoadEdge.points, curveRoadEdgeInfo.points);
    curveRoadEdge.curves = JSON.parse(JSON.stringify(curveRoadEdgeInfo.curves));
    curveRoadEdge.type = curveRoadEdgeInfo.type;
    curveRoadEdge.style = curveRoadEdgeInfo.style;
  }

  setCurveRoadInfo(curveRoadInfo) {
    let curveRoad = dataService.getCurveRoad(curveRoadInfo.vectorId);
    curveRoad.vectorId = curveRoadInfo.vectorId;
    curveRoad.startId = curveRoadInfo.startId;
    curveRoad.endId = curveRoadInfo.endId;
    curveRoad.leftEdgeId = curveRoadInfo.leftEdgeId;
    curveRoad.rightEdgeId = curveRoadInfo.rightEdgeId;
    for (let i = 0; i < curveRoadInfo.points.length; ++i) {
      curveRoad.points[i] = dataService.getCurveRoadPoint(
        curveRoadInfo.points[i]
      );
    }
    //curveRoad.points = JSON.parse(JSON.stringify(curveRoadInfo.points));
    curveRoad.curves = JSON.parse(JSON.stringify(curveRoadInfo.curves));

    if (curveRoad.way == Constant.oneWay) {
      curveRoad.singleCurveRoadWidth = curveRoadInfo.singleCurveRoadWidth;
      curveRoad.singleCurveRoadDrivewayCount =
        curveRoadInfo.singleCurveRoadDrivewayCount;
      curveRoad.singleLanesCurves = JSON.parse(
        JSON.stringify(curveRoadInfo.singleLanesCurves)
      );
    } else if (curveRoad.way == Constant.twoWay) {
      curveRoad.leftWidth = curveRoadInfo.leftWidth;
      curveRoad.rightWidth = curveRoadInfo.rightWidth;
      curveRoad.leftDrivewayCount = curveRoadInfo.leftDrivewayCount;
      curveRoad.rightDrivewayCount = curveRoadInfo.rightDrivewayCount;
      curveRoad.midDivide = JSON.parse(JSON.stringify(curveRoadInfo.midDivide));
      curveRoad.leftLanesCurves = JSON.parse(
        JSON.stringify(curveRoadInfo.leftLanesCurves)
      );
      curveRoad.rightLanesCurves = JSON.parse(
        JSON.stringify(curveRoadInfo.rightLanesCurves)
      );
    }
  }

  setCrossPointInfo(crossPointInfo) {
    let crossPoint = dataService.getCrossPoint3(crossPointInfo.vectorId);
    crossPoint.vectorId = crossPointInfo.vectorId;
    mathUtil.clonePoint(crossPoint, crossPointInfo.position);
    crossPoint.extremePoint = {};
    mathUtil.clonePoint(crossPoint.extremePoint, crossPointInfo.extremePoint);
    crossPoint.edgeInfo1 = JSON.parse(JSON.stringify(crossPointInfo.edgeInfo1));
    crossPoint.edgeInfo2 = JSON.parse(JSON.stringify(crossPointInfo.edgeInfo2));
    crossPoint.curves = JSON.parse(JSON.stringify(crossPointInfo.curves));
  }
}

const historyUtil = new HistoryUtil();
export { historyUtil };