traffic-laser/src/graphic/Renderer/Draw.js

import { dataService } from "../Service/DataService.js";
import { stateService } from "../Service/StateService.js";
import { coordinate } from "../Coordinate.js";
import Style from "@/graphic/CanvasStyle/index.js";
import VectorType from "../enum/VectorType.js";
import { mathUtil } from "../Util/MathUtil.js";
import ElementEvents from "../enum/ElementEvents.js";
import { elementService } from "../Service/ElementService.js";
import UIEvents from "@/graphic/enum/UIEvents.js";

const imgCache = {};
const help = {
  getVectorStyle(vector, geoType = vector.geoType) {
    const geoId = vector?.vectorId;
    if (!geoId) {
      return [Style[geoType], undefined];
    }

    const itemsEntry = [
      [stateService.getSelectItem(), "Select"],
      [stateService.getDraggingItem(), "Dragging"],
      [stateService.getFocusItem(), "Focus"],
    ];
    let currentAttr;

    return [
      itemsEntry.reduce((prev, [item, attr]) => {
        if (
          item &&
          // item.type === VectorType[geoType] &&
          geoId === item.vectorId
        ) {
          if (Style[attr] && Style[attr][geoType]) {
            currentAttr = attr;
            return Style[attr][geoType];
          }
        }
        return prev;
      }, Style[geoType]),
      currentAttr,
    ];
  },
  setVectorStyle(ctx, vector, geoType = vector.geoType) {
    const [styles, attr] = help.getVectorStyle(vector, geoType);
    for (const style in styles) {
      if (typeof styles[style] === "function") {
        styles[style](ctx, vector);
      } else {
        ctx[style] = styles[style];
      }
    }
    return [styles, attr];
  },
  transformCoves(lines) {
    return lines.map((line) =>
      line.map((line) => ({
        start: coordinate.getScreenXY(line.start),
        end: coordinate.getScreenXY(line.end),
        controls: line.controls.map(coordinate.getScreenXY.bind(coordinate)),
      }))
    );
  },
  drawCoves(ctx, coves) {
    for (const curve of coves) {
      ctx.beginPath();
      ctx.moveTo(curve.start.x, curve.start.y);
      if (curve.controls.length === 1) {
        ctx.quadraticCurveTo(
          curve.controls[0].x,
          curve.controls[0].y,
          curve.end.x,
          curve.end.y
        );
      } else {
        ctx.bezierCurveTo(
          curve.controls[0].x,
          curve.controls[0].y,
          curve.controls[1].x,
          curve.controls[1].y,
          curve.end.x,
          curve.end.y
        );
      }
      ctx.stroke();
    }
  },
  getReal(data) {
    return (data * coordinate.ratio * coordinate.zoom) / coordinate.defaultZoom;
  },
  getImage(src) {
    if (imgCache[src]) {
      return imgCache[src];
    }
    const img = new Image();
    img.src = src;
    return (imgCache[src] = new Promise((resolve) => {
      img.onload = () => {
        resolve(img);
      };
    }));
  },
};

export default class Draw {
  constructor() {
    this.canvas = null;
    this.context = null;
  }

  initContext(canvas) {
    if (canvas) {
      this.canvas = canvas;
      this.context = canvas.getContext("2d");
    } else {
      this.context = null;
      this.canvas = null;
    }
  }

  clear() {
    this.context.clearRect(
      0,
      0,
      this.context.canvas.width,
      this.context.canvas.height
    );
  }

  drawBackGroundImg(vector) {
    const img = vector.imageData;
    const width = help.getReal(img.width);
    const height = help.getReal(img.height);
    const center = coordinate.getScreenXY(vector.center);
    this.context.save();
    this.context.drawImage(
      img,
      center.x - width / 2,
      center.y - height / 2,
      width,
      height
    );
    this.context.restore();
  }

  drawGrid(startX, startY, w, h, step1, step2) {
    this.context.save();
    this.context.beginPath();
    for (var x = startX; x <= w; x += step1) {
      this.context.moveTo(x, 0);
      this.context.lineTo(x, h);
    }

    for (var y = startY; y <= h; y += step1) {
      this.context.moveTo(0, y);
      this.context.lineTo(w, y);
    }
    this.context.strokeStyle = "rgba(0,0,0,0.1)";
    this.context.lineWidth = 0.5;
    this.context.stroke();

    this.context.beginPath();
    for (var x = startX; x <= w; x += step2) {
      this.context.moveTo(x, 0);
      this.context.lineTo(x, h);
    }

    for (var y = startY; y <= h; y += step2) {
      this.context.moveTo(0, y);
      this.context.lineTo(w, y);
    }
    this.context.strokeStyle = "rgba(0,0,0,0.2)";
    this.context.lineWidth = 1;
    this.context.stroke();
    this.context.restore();
  }

  drawRoad(vector, isTemp) {
    if (!isTemp && vector.display && vector.way !== "oneWay") {
      const ctx = this.context;
      const draw = (midDivide) => {
        const startScreen = coordinate.getScreenXY(midDivide.start);
        const endScreen = coordinate.getScreenXY(midDivide.end);
        ctx.beginPath();
        ctx.moveTo(startScreen.x, startScreen.y);
        ctx.lineTo(endScreen.x, endScreen.y);
        ctx.stroke();
      };

      ctx.save();
      help.setVectorStyle(ctx, vector);
      vector.midDivide.leftMidDivide && draw(vector.midDivide.leftMidDivide);
      vector.midDivide.rightMidDivide && draw(vector.midDivide.rightMidDivide);
      ctx.restore();
    }

    if (import.meta.env.DEV && !isTemp) {
      const startReal = isTemp
        ? vector.start
        : dataService.getRoadPoint(vector.startId);
      const endReal = isTemp
        ? vector.end
        : dataService.getRoadPoint(vector.endId);
      this.drawTextByInfo(
        { x: (startReal.x + endReal.x) / 2, y: (startReal.y + endReal.y) / 2 },
        vector.vectorId
      );
    }
    this.drawRoadEdge(vector, isTemp);
    vector.leftLanes && vector.leftLanes.forEach(this.drawLan.bind(this));
    vector.rightLanes && vector.rightLanes.forEach(this.drawLan.bind(this));
  }

  drawLan(lan) {
    const ctx = this.context;
    const start = coordinate.getScreenXY(lan.start);
    const end = coordinate.getScreenXY(lan.end);
    ctx.save();
    ctx.beginPath();
    help.setVectorStyle(ctx, null, "Lane");
    ctx.setLineDash(Style.Lane.dash);
    ctx.moveTo(start.x, start.y);
    ctx.lineTo(end.x, end.y);
    ctx.stroke();
    ctx.restore();

    if (import.meta.env.DEV) {
      this.drawPoint(lan.start);
      this.drawPoint(lan.end);
    }
  }

  drawRoadEdge(vector, isTemp) {
    //判断是否与road方向一致。角度足够小，路足够宽，有可能向量方向不一致
    const start = isTemp
      ? vector.start
      : dataService.getRoadPoint(vector.startId);
    const end = isTemp ? vector.end : dataService.getRoadPoint(vector.endId);

    const drawRoadEdgeChild = (edgeVector) => {
      const flag = mathUtil.isSameDirForVector(
        start,
        end,
        edgeVector.start,
        edgeVector.end
      );

      if (flag) {
        ctx.beginPath();
        const point1 = coordinate.getScreenXY(edgeVector.start);
        const point2 = coordinate.getScreenXY(edgeVector.end);
        ctx.moveTo(point1.x, point1.y);
        ctx.lineTo(point2.x, point2.y);
        ctx.stroke();
      }
      this.drawTextByInfo(
        {
          x: (edgeVector.start.x + edgeVector.end.x) / 2,
          y: (edgeVector.start.y + edgeVector.end.y) / 2,
        },
        edgeVector.vectorId
      );
    };

    const leftEdge = isTemp
      ? vector.leftEdge
      : dataService.getRoadEdge(vector.leftEdgeId);
    const rightEdge = isTemp
      ? vector.rightEdge
      : dataService.getRoadEdge(vector.rightEdgeId);
    const ctx = this.context;
    ctx.save();
    isTemp && (ctx.globalAlpha = 0.3);
    help.setVectorStyle(ctx, leftEdge);
    drawRoadEdgeChild(leftEdge);
    help.setVectorStyle(ctx, rightEdge);
    drawRoadEdgeChild(rightEdge);
    ctx.restore();

    if (import.meta.env.DEV) {
      this.drawPoint(leftEdge.start);
      this.drawPoint(leftEdge.end);
      this.drawPoint(rightEdge.start);
      this.drawPoint(rightEdge.end);
    }
  }

  drawCrossPoint(vector) {
    const start = coordinate.getScreenXY(
      dataService
        .getRoadEdge(vector.edgeInfo1.id)
        .getPosition(vector.edgeInfo1.dir)
    );
    const end = coordinate.getScreenXY(
      dataService
        .getRoadEdge(vector.edgeInfo2.id)
        .getPosition(vector.edgeInfo2.dir)
    );
    const pt2 = mathUtil.twoOrderBezier(
      0.5,
      start,
      coordinate.getScreenXY({ x: vector.x, y: vector.y }),
      end
    );
    const pt = mathUtil.twoOrderBezier2(0.5, start, pt2, end);
    const extremePoint = coordinate.getScreenXY(vector.extremePoint);
    const ctx = this.context;
    ctx.save();
    ctx.strokeStyle = "red";
    ctx.beginPath();
    ctx.arc(
      // pt.x,
      // pt.y,
      extremePoint.x,
      extremePoint.y,
      Style.CrossPoint.radius * coordinate.ratio,
      0,
      Math.PI * 2,
      true
    );
    ctx.stroke();
    ctx.fill();
    ctx.restore();

    ctx.save();
    ctx.beginPath();
    help.setVectorStyle(ctx, null, "RoadEdge");
    //曲线
    // ctx.moveTo(start.x, start.y);
    // ctx.quadraticCurveTo(pt.x, pt.y, end.x, end.y);

    const [coves] = help.transformCoves([vector.curves]);
    help.drawCoves(ctx, coves);
    ctx.restore();
  }

  drawCurveRoad(vector) {
    if (vector.display && vector.midDivide) {
      const covesArray = help.transformCoves([
        vector.midDivide.leftMidDivideCurves,
        vector.midDivide.rightMidDivideCurves,
      ]);
      const ctx = this.context;
      ctx.save();
      help.setVectorStyle(ctx, vector);
      for (let coves of covesArray) {
        help.drawCoves(ctx, coves);
      }
      ctx.restore();
    }

    this.drawCurveRoadEdge(dataService.getCurveRoadEdge(vector.rightEdgeId));
    this.drawCurveRoadEdge(dataService.getCurveRoadEdge(vector.leftEdgeId));
    vector.leftLanesCurves &&
      vector.leftLanesCurves.forEach(this.drawCurveLan.bind(this));
    vector.rightLanesCurves &&
      vector.rightLanesCurves.forEach(this.drawCurveLan.bind(this));

    if (import.meta.env.DEV) {
      vector.points.forEach(this.drawPoint.bind(this));
    }
  }

  drawCurveRoadEdge(vector, isTemp) {
    const [coves] = help.transformCoves([vector.curves]);
    const ctx = this.context;
    ctx.save();
    help.setVectorStyle(ctx, vector);
    help.drawCoves(ctx, coves);
    ctx.restore();

    if (import.meta.env.DEV) {
      vector.points.forEach(this.drawPoint.bind(this));
    }
  }

  drawCurveLan(lines) {
    const [coves] = help.transformCoves([lines]);
    const ctx = this.context;
    ctx.save();

    help.setVectorStyle(ctx, null, "CurveLan");
    ctx.setLineDash(Style.Lane.dash);
    help.drawCoves(ctx, coves);
    ctx.restore();

    if (import.meta.env.DEV) {
      lines.map((line) => {
        this.drawPoint(line.start);
        this.drawPoint(line.end);
      });
    }
  }

  drawRoadPoint(vector) {
    this.drawPoint(vector);
  }

  drawArrow(vector) {
    const startReal = dataService.getPoint(vector.startId);
    const start = coordinate.getScreenXY(startReal);
    const endReal = dataService.getPoint(vector.endId);
    const end = coordinate.getScreenXY(endReal);
    const ctx = this.context;

    ctx.save();

    const [style] = help.setVectorStyle(this.context, vector, "Arrow");
    if (vector.arrowColor) {
      ctx.strokeStyle = vector.arrowColor;
    }
    ctx.beginPath();
    ctx.moveTo(start.x, start.y);
    ctx.lineTo(end.x, end.y);

    const dires =
      vector.category === UIEvents.MeasureLine
        ? [
            [start, end],
            [end, start],
          ]
        : [[start, end]];
    for (let [start, end] of dires) {
      const lines = mathUtil.getArrow(start, end);
      ctx.moveTo(lines[0].x, lines[0].y);
      ctx.lineTo(lines[1].x, lines[1].y);
      ctx.lineTo(lines[2].x, lines[2].y);
    }
    ctx.stroke();
    ctx.restore();

    if ([Style.Focus.Arrow, Style.Select.Arrow].includes(style)) {
      this.drawPoint(startReal);
      this.drawPoint(endReal);
    }
  }

  drawMagnifier(vector) {
    const ctx = this.context;
    this.drawPoint({
      ...vector,
      ...vector.position,
      radius: Style.Magnifier.radius,
    });
    const pt = coordinate.getScreenXY(vector.position);
    const target = coordinate.getScreenXY(vector.popPosition);
    const [style] = help.setVectorStyle(ctx, vector);
    const radius = help.getReal(vector.radius || style.radius);
    const offset = radius / 2;
    const targetPts =
      style === Style.Focus.Magnifier
        ? [mathUtil.translate(pt, target, pt, radius), target]
        : null;

    ctx.save();
    ctx.beginPath();
    ctx.moveTo(pt.x - offset, pt.y);
    ctx.lineTo(pt.x + offset, pt.y);
    ctx.stroke();
    ctx.beginPath();
    ctx.moveTo(pt.x, pt.y - offset);
    ctx.lineTo(pt.x, pt.y + offset);
    ctx.stroke();

    if (targetPts) {
      ctx.beginPath();
      ctx.moveTo(targetPts[0].x, targetPts[0].y);
      ctx.lineTo(targetPts[1].x, targetPts[1].y);
      ctx.stroke();

      let img, imgBound;
      if (vector.photoImage) {
        img = vector.photoImage;
        imgBound = [0, 0, img.width, img.height];
      } else {
        const size = help.getReal(style.target.realRadius);
        const backImg = dataService.getBackgroundImg();
        img = backImg.imageData;
        const imgCenter = coordinate.getScreenXY(backImg.center);
        const start = {
          x: imgCenter.x - help.getReal(img.width) / 2,
          y: imgCenter.y - help.getReal(img.height) / 2,
        };
        const ro = img.width / help.getReal(img.width);
        imgBound = [
          (pt.x - start.x - size) * ro,
          (pt.y - start.y - size) * ro,
          size * 2 * ro,
          size * 2 * ro,
        ];
      }
      const size = help.getReal(style.target.radius);
      ctx.beginPath();
      ctx.arc(target.x, target.y, size, 0, 2 * Math.PI);
      ctx.clip();
      ctx.drawImage(
        img,
        ...imgBound,
        target.x - size,
        target.y - size,
        size * 2,
        size * 2
      );
      ctx.strokeStyle = style.target.strokeStyle;
      ctx.lineWidth = style.target.lineWidth;
      ctx.stroke();
    }
    ctx.restore();
  }

  drawCircle(element) {
    this.drawPoint({
      ...element,
      geoType: "Circle",
      ...element.center,
    });

    element.points.forEach((point) => this.drawPoint(point));
  }

  drawPoint(vector) {
    const pt = coordinate.getScreenXY({ x: vector.x, y: vector.y });
    const ctx = this.context;
    const [style] = help.setVectorStyle(ctx, vector, vector.geoType || "Point");
    if (vector.color) {
      ctx.strokeStyle = vector.color;
    }
    const radius = help.getReal(vector.radius || style.radius);
    ctx.save();
    ctx.beginPath();
    ctx.arc(pt.x, pt.y, radius, 0, Math.PI * 2, true);
    ctx.stroke();
    ctx.fill();
    ctx.restore();

    if (import.meta.env.DEV) {
      if (vector.vectorId) {
        this.drawTextByInfo(vector, vector.vectorId);
      }
    }
  }

  drawTextByInfo(position, txt, angle, setStyle = true) {
    const ctx = this.context;
    ctx.save();
    setStyle && help.setVectorStyle(ctx, null, "Text");

    const pt = coordinate.getScreenXY(position);
    const text = ctx.measureText(txt);
    pt.x -= text.width / 2;
    pt.y += (text.actualBoundingBoxAscent + text.actualBoundingBoxDescent) / 2;
    if (angle) {
      ctx.translate(pt.x, pt.y);
      ctx.rotate(angle);
      ctx.fillText(txt, 0, 0);
    } else {
      ctx.fillText(txt, pt.x, pt.y);
    }
    ctx.restore();
  }

  // 文字
  drawText(vector) {
    help.setVectorStyle(this.context, vector);
    this.context.fillStyle = vector.color;
    const oldFont = this.context.font;
    this.context.font = `${vector.fontSize}px Microsoft YaHei`;
    this.drawTextByInfo(vector.center, vector.value, 0, false);

    const ctx = this.context;
    const pt = coordinate.getScreenXY(vector.center);
    const text = ctx.measureText(vector.value);
    pt.x -= text.width / 2;
    pt.y += (text.actualBoundingBoxAscent + text.actualBoundingBoxDescent) / 2;

    this.context.font = oldFont;
  }

  drawLine(vector) {
    if ([UIEvents.Arrow, UIEvents.MeasureLine].includes(vector.category)) {
      return this.drawArrow(vector);
    }
    const startReal = dataService.getPoint(vector.startId);
    const start = coordinate.getScreenXY(startReal);
    const endReal = dataService.getPoint(vector.endId);
    const end = coordinate.getScreenXY(endReal);

    this.context.save();
    const [style, attr] = help.setVectorStyle(
      this.context,
      vector,
      vector.category || vector.geoType
    );
    if (style.dash) {
      this.context.setLineDash(style.dash);
    }
    this.context.beginPath();
    this.context.moveTo(start.x, start.y);
    this.context.lineTo(end.x, end.y);
    this.context.stroke();
    this.context.restore();

    // if (attr) {
    //   this.drawPoint(startReal)
    //   this.drawPoint(endReal)
    // }
  }

  drawElementLine(element) {
    let start = elementService.getPoint(element.startId);
    start = coordinate.getScreenXY(start);
    let end = elementService.getPoint(element.endId);
    end = coordinate.getScreenXY(end);

    this.context.save();
    const [style] = help.setVectorStyle(
      this.context,
      element,
      element.category || element.geoType
    );

    if (style.dash) {
      this.context.setLineDash(style.dash);
    }
    this.context.beginPath();
    this.context.moveTo(start.x, start.y);
    this.context.lineTo(end.x, end.y);
    this.context.stroke();
    this.context.restore();
  }
}

const draw = new Draw();
export { draw };