JavaScript Canvas绘制雷达扫描动画及车辆标记实现

作者:白露

时间:2026-11-17

浏览:280

详细讲解如何使用原生 JavaScript 与 HTML5 Canvas 绘制高保真雷达扫描动画,并实现车辆目标的极坐标映射、光束命中高亮、指数余晖衰减以及车辆航向与信息标签渲染。

文章目录
分类:前端图形学与数据可视化 技术栈:HTML5 Canvas / 原生 JavaScript 阅读时长:约 12 分钟 难度级别:中级实用教程
在车载智能座舱、智能网联汽车监控中心或数字孪生大屏项目中,雷达扫描界面与车辆目标跟踪是极其常见的可视化组件。使用 HTML5 Canvas 绘制雷达扫描动画并标记车辆,核心在于三项工作:一是基于物理像素比适配高清画板并绘制同心圆与方位轴刻度;二是基于 requestAnimationFrame 驱动具有渐变尾迹衰减的扇形扫描波束;三是将车辆目标的物理极坐标(距离与方位角)实时换算为 Canvas 直角坐标,并在光束切过瞬间触发高亮闪烁、扩散警示波纹与指数余晖衰减。本文将拆解完整的实现步骤,提供无第三方依赖的原生实现方案。
JavaScript Canvas绘制雷达扫描动画及车辆标记实现
图 1:雷达扫描动画与车辆目标动态标记系统整体界面预览

一、基础环境准备与 Canvas 高清屏适配

在 HTML 页面中,直接通过 CSS 设置宽高往往会导致 Canvas 内部位图按默认的 300×150 像素拉伸,特别是在 Retina 或移动设备上,画面会出现明显的文字发虚与线条毛刺。因此,初始化的第一步是读取设备的 window.devicePixelRatio(设备像素比),将 Canvas 的内部物理像素宽度放大,再用 CSS 样式将其约束在逻辑视口内。

完成分辨率适配后,雷达以圆心为对称基准,若每次绘制都手动累加偏移量,代码会充斥大量冗余的 centerX + r * ...。最佳实践是在初始化或重绘时调用 ctx.translate(centerX, centerY) 将绘图坐标原点直接移至雷达中心。这样圆心即为 (0, 0),极坐标换算与旋转变换均可直接在此基础上展开。

// 获取画布与上下文
const canvas = document.getElementById('radarCanvas');
const ctx = canvas.getContext('2d');

function setupHiDPI(canvas, ctx, cssWidth, cssHeight) {
  const dpr = window.devicePixelRatio || 1;
  // 设置 Canvas 实际缓冲像素尺寸
  canvas.width = Math.round(cssWidth * dpr);
  canvas.height = Math.round(cssHeight * dpr);

  // 设置 CSS 显示尺寸
  canvas.style.width = `${cssWidth}px`;
  canvas.style.height = `${cssHeight}px`;

  // 重置并按像素比缩放上下文
  ctx.setTransform(1, 0, 0, 1, 0, 0);
  ctx.scale(dpr, dpr);
}

// 执行初始化
const width = 600;
const height = 600;
setupHiDPI(canvas, ctx, width, height);
const center = { x: width / 2, y: height / 2 };
const maxRadius = Math.min(width, height) / 2 - 30; // 预留边界内边距

二、核心实现步骤与渲染管线

要让雷达扫描与车辆标记保持流畅的 60FPS 运行,必须建立明确的逐帧渲染管线。雷达界面由静态背景(量程刻度环、十字十字线)、动态扫描光束(扇形渐变余晖)和动态目标(车辆光斑、速度方向、标签卡片)三个层次叠加而成。

JavaScript Canvas绘制雷达扫描动画及车辆标记实现
图 2:雷达扫描与车辆目标渲染流水线(六大关键步骤与生命周期闭环)

如上图所示,渲染循环在每一帧触发时,遵循以下确定顺序执行:

  1. 清屏与状态保存:调用 ctx.clearRect(0, 0, width, height) 清除上一帧像素,并使用 ctx.save() 记录当前全局变换栈。
  2. 坐标系平移:调用 ctx.translate(center.x, center.y),统一将原点设为圆心。
  3. 绘制静态刻度底盘:画出等距同心圆、方位角分割线及距离文本(如 50m、100m、150m、200m)。
  4. 绘制扫描扇面与波束:基于当前时间累加计算的扫描角 currentAngle,绘制带有角度渐变的半透明扇形。
  5. 遍历并标记车辆目标:将各车辆从极坐标换算至屏幕直角坐标,判定是否被当前光束扫中,并根据时间差衰减 Alpha 透明度后绘制标记符号。
  6. 状态恢复与循环调度:执行 ctx.restore() 恢复环境,通过 requestAnimationFrame 注册下一帧回调。

三、静态刻度盘与量程环绘制

雷达刻度盘用于让观测者直观评估目标的相对方位和物理距离。通常由多层等距同心圆环(量程环)、垂直水平十字主轴、45°辅助方位角虚线以及距离文本标注构成。

function drawRadarDial(ctx, radius, rings = 4, maxDistance = 200) {
  ctx.save();
  ctx.lineWidth = 1;
  ctx.strokeStyle = '#345E82';
  ctx.fillStyle = '#345E82';
  ctx.font = '11px -apple-system, sans-serif';
  ctx.textAlign = 'left';
  ctx.textBaseline = 'bottom';

  // 1. 绘制等距同心圆
  const ringStep = radius / rings;
  for (let i = 1; i <= rings; i++) {
    const r = ringStep * i;
    ctx.beginPath();
    ctx.arc(0, 0, r, 0, Math.PI * 2);
    // 最外圈实线,内圈虚线
    if (i === rings) {
      ctx.setLineDash([]);
      ctx.lineWidth = 1.5;
    } else {
      ctx.setLineDash([4, 4]);
      ctx.lineWidth = 0.8;
    }
    ctx.stroke();

    // 绘制距离标识(沿 Y 轴上方标注物理米数)
    const meterVal = Math.round((maxDistance / rings) * i);
    ctx.fillText(`${meterVal}m`, 4, -r + 14);
  }

  // 2. 绘制十字十字线与对角线
  ctx.setLineDash([]);
  ctx.lineWidth = 1;
  // X 轴与 Y 轴
  ctx.beginPath();
  ctx.moveTo(-radius, 0); ctx.lineTo(radius, 0);
  ctx.moveTo(0, -radius); ctx.lineTo(0, radius);
  ctx.stroke();

  // 45° 辅助虚线
  ctx.beginPath();
  ctx.setLineDash([2, 4]);
  const diag = radius * Math.SQRT1_2;
  ctx.moveTo(-diag, -diag); ctx.lineTo(diag, diag);
  ctx.moveTo(-diag, diag); ctx.lineTo(diag, -diag);
  ctx.stroke();

  // 中心基点
  ctx.beginPath();
  ctx.setLineDash([]);
  ctx.arc(0, 0, 3, 0, Math.PI * 2);
  ctx.fillStyle = '#AD8060';
  ctx.fill();

  ctx.restore();
}

四、扫描光束与扇形余晖动画实现

传统雷达扫描效果的精髓在于“前沿光束亮、后沿余晖淡”。在现代 Canvas 中,有两种方式实现这一渐变效果:一是使用标准 API ctx.createConicGradient()(锥形渐变),二是使用等角度微切片(Micro-slice Arcs)叠加绘制。

锥形渐变在部分旧版环境或离屏 Canvas 中可能存在兼容性差异;而微切片切分法则具备极佳的兼容性且渲染开销完全可控。此处我们演示采用原生角度分片生成平滑扇形余晖的算法:将宽度例如为 45°(0.785 弧度)的扫描扇区细分为 20~30 个微小弧形扇片,从后沿到前沿透明度逐渐从 0.0 线性或指数增加至 0.35,前沿最亮处再叠加一条实线扫描标线。

JavaScript Canvas绘制雷达扫描动画及车辆标记实现
图 3:极坐标转直角坐标投影原理与扫描光束夹角相交判定几何
function drawSweepBeam(ctx, radius, currentAngle, tailAngle = Math.PI / 4, slices = 25) {
  ctx.save();

  // 1. 绘制带透明度衰减的扇形余晖
  for (let i = 0; i < slices; i++) {
    // 计算当前切片的起始和终止角
    const startRatio = i / slices;
    const endRatio = (i + 1) / slices;
    const a1 = currentAngle - tailAngle * (1 - startRatio);
    const a2 = currentAngle - tailAngle * (1 - endRatio);

    // Alpha 由尾部 0 递增到头部 0.35
    const alpha = (startRatio * 0.35).toFixed(4);

    ctx.beginPath();
    ctx.moveTo(0, 0);
    ctx.arc(0, 0, radius, a1, a2, false);
    ctx.closePath();
    ctx.fillStyle = `rgba(52, 94, 130, ${alpha})`;
    ctx.fill();
  }

  // 2. 绘制最前沿的扫描锐线
  ctx.beginPath();
  ctx.moveTo(0, 0);
  ctx.lineTo(radius * Math.cos(currentAngle), radius * Math.sin(currentAngle));
  ctx.strokeStyle = '#345E82';
  ctx.lineWidth = 2;
  ctx.stroke();

  ctx.restore();
}

五、车辆目标极坐标解算与相交判定

在实际车联网或自动驾驶传感器(如激光雷达、毫米波雷达)通信协议中,目标位置通常以物理极坐标形式广播,包含:

  • distance:目标距本车的物理直线距离(单位:米)。
  • azimuth:相对本车朝向的方位角(单位:弧度或度)。
  • speed:车辆对地速度(单位:km/h 或 m/s)。
  • heading:车辆航向角(相对雷达正北或车头的旋转角度)。

1. 坐标转换公式

将物理距离换算为 Canvas 像素半径:r_pixel = (distance / maxDistance) * radius。接着由三角函数得出中心坐标系下的直角坐标:

const x = r_pixel * Math.cos(target.azimuth);
const y = r_pixel * Math.sin(target.azimuth);

2. 扫描线相交与命中判定

由于扫描线角 currentAngle 随着时间单调递增,并对 $2\pi$ 取模,当扫描线前沿扫过车辆方位角 target.azimuth 的瞬间,我们需要标记该车辆被“探测命中”,并记录命中时间戳 lastHitTime = performance.now()。

注意角度跨周期边界处理:扫描角从 $1.99\pi$ 跨越到 $0.01\pi$ 时,不能用简单数值差 |angle1 - angle2|。正确的角差归一化公式为:let diff = (currentAngle - target.azimuth) % (2 * Math.PI); if (diff < 0) diff += 2 * Math.PI;。当 diff < angularSpeed * deltaTime(即这一帧内扫描线扫过的扇形包含了目标方位角),判定为精准命中。

六、车辆标记绘制与余晖衰减生命周期

真实雷达显示器(如 CRT 时代采用 P7 荧光粉)在电子束扫过荧光屏表面后,亮点会爆发出极高亮度,随后按指数规律逐渐淡化。在 Canvas 中模拟这种物理质感,能极大提升可视化的沉浸度与可读性。

JavaScript Canvas绘制雷达扫描动画及车辆标记实现
图 4:车辆目标从瞬时命中到指数衰减的完整生命周期与 Alpha 时序曲线

为车辆标记设计完整的状态表现:

  • 命中爆发态(Hit Peak):当检测到扫描线切过,Alpha 跃升至 1.0,并触发一圈向外扩散的同心脉冲警示环(Pulse Alert Ring)。
  • 指数余晖衰减态(Decay):依据公式 $lpha(t) = lpha_{base} + (1 - lpha_{base}) \cdot e^{-\lambda \Delta t}$,随时间衰减。设定基底底色 $lpha_{base} = 0.18$,确保即便未扫过也能微弱看清车辆轮廓。
  • 航向箭头与数据卡片:在光斑中心根据 heading 旋转绘制三角形航向标,并在其侧上方绘制包含车辆 ID、物理距离和当前车速的信息卡。
function drawVehicleMarker(ctx, target, scaleRadius, maxDist, now) {
  // 1. 距离换算与坐标计算
  const r = (target.distance / maxDist) * scaleRadius;
  const x = r * Math.cos(target.azimuth);
  const y = r * Math.sin(target.azimuth);

  // 2. 指数衰减 Alpha 计算
  const elapsed = (now - target.lastHitTime) / 1000; // 距上次命中秒数
  const decayRate = 2.0; // 衰减系数
  const baseAlpha = 0.15;
  const alpha = Math.min(1.0, baseAlpha + (1 - baseAlpha) * Math.exp(-decayRate * elapsed));

  ctx.save();
  ctx.translate(x, y);

  // 3. 命中瞬间的向外扩散涟漪环
  if (elapsed < 0.6) {
    const waveProgress = elapsed / 0.6;
    const waveRadius = 6 + waveProgress * 18;
    const waveAlpha = (1 - waveProgress) * 0.9;
    ctx.beginPath();
    ctx.arc(0, 0, waveRadius, 0, Math.PI * 2);
    ctx.strokeStyle = `rgba(173, 128, 96, ${waveAlpha})`; // 铜棕强调色
    ctx.lineWidth = 1.5;
    ctx.stroke();
  }

  // 4. 车辆中心实体圆点
  ctx.beginPath();
  ctx.arc(0, 0, 4.5, 0, Math.PI * 2);
  ctx.fillStyle = `rgba(173, 128, 96, ${alpha})`;
  ctx.fill();

  // 5. 航向角三角形标识
  ctx.save();
  ctx.rotate(target.heading);
  ctx.beginPath();
  ctx.moveTo(0, -9);
  ctx.lineTo(4.5, 5);
  ctx.lineTo(-4.5, 5);
  ctx.closePath();
  ctx.fillStyle = `rgba(52, 94, 130, ${alpha})`;
  ctx.fill();
  ctx.restore();

  // 6. 车辆信息数据小卡片(当 Alpha 足够清晰时绘制)
  if (alpha > 0.35) {
    ctx.font = '9px monospace';
    ctx.fillStyle = `rgba(52, 94, 130, ${alpha})`;
    const labelId = target.id;
    const labelDist = `${Math.round(target.distance)}m`;
    const labelSpeed = `${Math.round(target.speed)}km/h`;

    // 绘制微型文本框
    ctx.fillRect(8, -18, 62, 26);
    ctx.fillStyle = '#FFFFFF';
    ctx.fillText(labelId, 12, -7);
    ctx.fillStyle = `rgba(173, 128, 96, ${alpha})`;
    ctx.fillText(`${labelDist} | ${labelSpeed}`, 12, 4);
  }

  ctx.restore();
}

七、完整可运行工程实现代码

下面给出一个高内聚、模块化封装的完整单文件示例。代码将雷达抽象为 RadarDisplay 类,自适应高分辨率屏幕,集成真实时间步长驱动动画,并自带 4 辆具有不同距离、方位和航向的模拟车辆。读者可将其复制至本地 .html 文件直接在浏览器中打开验证。

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <title>Canvas 雷达扫描与车辆标记演示</title>
  <style>
    body {
      background: #F2F6FA;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      min-height: 100vh;
      margin: 0;
      font-family: sans-serif;
    }
    .radar-container {
      background: #FFFFFF;
      padding: 16px;
      border-radius: 8px;
      box-shadow: 0 4px 16px rgba(52, 94, 130, 0.12);
      border: 1px solid #D3DFEB;
    }
    canvas {
      display: block;
    }
  </style>
</head>
<body>
  <div class="radar-container">
    <canvas id="radar"></canvas>
  </div>

  <script>
    class RadarDisplay {
      constructor(canvasId, size = 560, maxRange = 200) {
        this.canvas = document.getElementById(canvasId);
        this.ctx = this.canvas.getContext('2d');
        this.size = size;
        this.maxRange = maxRange;
        this.radius = size / 2 - 25;

        // 扫描参数:旋转角速度 (每秒 1 圈即 2*PI 弧度)
        this.currentAngle = 0;
        this.angularSpeed = Math.PI; // 0.5 转/秒 (180 deg/s)
        this.tailAngle = Math.PI / 3; // 60 度余晖尾翼
        this.lastTimestamp = performance.now();

        // 模拟车辆数据源
        this.vehicles = [
          { id: 'CAR-01', distance: 65,  azimuth: 0.85,  speed: 45, heading: 0.2,  lastHitTime: 0 },
          { id: 'TRK-02', distance: 135, azimuth: 2.40,  speed: 30, heading: 2.1,  lastHitTime: 0 },
          { id: 'BUS-03', distance: 180, azimuth: 4.10,  speed: 55, heading: 3.8,  lastHitTime: 0 },
          { id: 'SUV-04', distance: 95,  azimuth: 5.35,  speed: 68, heading: 5.6,  lastHitTime: 0 }
        ];

        this.initHiDPI();
        this.render = this.render.bind(this);
        requestAnimationFrame(this.render);
      }

      initHiDPI() {
        const dpr = window.devicePixelRatio || 1;
        this.canvas.width = this.size * dpr;
        this.canvas.height = this.size * dpr;
        this.canvas.style.width = `${this.size}px`;
        this.canvas.style.height = `${this.size}px`;
        this.ctx.scale(dpr, dpr);
      }

      render(now) {
        const dt = (now - this.lastTimestamp) / 1000;
        this.lastTimestamp = now;

        // 1. 推进扫描线角度
        const prevAngle = this.currentAngle;
        this.currentAngle = (this.currentAngle + this.angularSpeed * dt) % (Math.PI * 2);

        // 2. 清屏与原点平移
        this.ctx.clearRect(0, 0, this.size, this.size);
        this.ctx.save();
        this.ctx.translate(this.size / 2, this.size / 2);

        // 3. 绘制静态标尺盘
        this.drawDial();

        // 4. 绘制动态扫描光束与扇形余晖
        this.drawSweep();

        // 5. 命中检测与车辆标记
        this.updateAndDrawVehicles(prevAngle, this.currentAngle, now);

        this.ctx.restore();

        // 驱动下一帧
        requestAnimationFrame(this.render);
      }

      drawDial() {
        const ctx = this.ctx;
        ctx.save();
        ctx.strokeStyle = '#345E82';
        ctx.fillStyle = '#345E82';
        ctx.lineWidth = 1;
        ctx.font = '10px monospace';

        // 同心量程环
        const rings = 4;
        for (let i = 1; i <= rings; i++) {
          const r = (this.radius / rings) * i;
          ctx.beginPath();
          ctx.arc(0, 0, r, 0, Math.PI * 2);
          ctx.setLineDash(i === rings ? [] : [4, 4]);
          ctx.stroke();

          // 距离标尺
          const distVal = Math.round((this.maxRange / rings) * i);
          ctx.fillText(`${distVal}m`, 4, -r + 12);
        }

        // 十字准星与45度分划线
        ctx.setLineDash([]);
        ctx.beginPath();
        ctx.moveTo(-this.radius, 0); ctx.lineTo(this.radius, 0);
        ctx.moveTo(0, -this.radius); ctx.lineTo(0, this.radius);
        ctx.stroke();

        ctx.setLineDash([2, 4]);
        const d = this.radius * Math.SQRT1_2;
        ctx.beginPath();
        ctx.moveTo(-d, -d); ctx.lineTo(d, d);
        ctx.moveTo(-d, d); ctx.lineTo(d, -d);
        ctx.stroke();

        ctx.restore();
      }

      drawSweep() {
        const ctx = this.ctx;
        const slices = 30;
        ctx.save();

        for (let i = 0; i < slices; i++) {
          const startRatio = i / slices;
          const endRatio = (i + 1) / slices;
          const a1 = this.currentAngle - this.tailAngle * (1 - startRatio);
          const a2 = this.currentAngle - this.tailAngle * (1 - endRatio);
          const alpha = startRatio * 0.32;

          ctx.beginPath();
          ctx.moveTo(0, 0);
          ctx.arc(0, 0, this.radius, a1, a2, false);
          ctx.closePath();
          ctx.fillStyle = `rgba(52, 94, 130, ${alpha})`;
          ctx.fill();
        }

        // 扫描前沿亮线
        ctx.beginPath();
        ctx.moveTo(0, 0);
        ctx.lineTo(this.radius * Math.cos(this.currentAngle), this.radius * Math.sin(this.currentAngle));
        ctx.strokeStyle = '#345E82';
        ctx.lineWidth = 2;
        ctx.stroke();

        ctx.restore();
      }

      updateAndDrawVehicles(prevAngle, currentAngle, now) {
        const ctx = this.ctx;

        this.vehicles.forEach(v => {
          // 判定本帧扫描线是否切过该车辆方位角
          let diff = (currentAngle - v.azimuth) % (Math.PI * 2);
          if (diff < 0) diff += Math.PI * 2;
          const sweepStep = (currentAngle - prevAngle + Math.PI * 2) % (Math.PI * 2);

          // 当角差小于单帧跨度,触发命中
          if (diff <= sweepStep && v.distance <= this.maxRange) {
            v.lastHitTime = now;
          }

          // 极坐标转换
          const r = (v.distance / this.maxRange) * this.radius;
          const x = r * Math.cos(v.azimuth);
          const y = r * Math.sin(v.azimuth);

          // 指数余晖衰减
          const elapsed = (now - v.lastHitTime) / 1000;
          const alpha = Math.min(1.0, 0.18 + 0.82 * Math.exp(-2.2 * elapsed));

          ctx.save();
          ctx.translate(x, y);

          // 扩散波纹
          if (elapsed < 0.5) {
            const p = elapsed / 0.5;
            ctx.beginPath();
            ctx.arc(0, 0, 5 + p * 15, 0, Math.PI * 2);
            ctx.strokeStyle = `rgba(173, 128, 96, ${1 - p})`;
            ctx.lineWidth = 1.2;
            ctx.stroke();
          }

          // 中心点
          ctx.beginPath();
          ctx.arc(0, 0, 4, 0, Math.PI * 2);
          ctx.fillStyle = `rgba(173, 128, 96, ${alpha})`;
          ctx.fill();

          // 航向三角
          ctx.rotate(v.heading);
          ctx.beginPath();
          ctx.moveTo(0, -8); ctx.lineTo(4, 4); ctx.lineTo(-4, 4);
          ctx.closePath();
          ctx.fillStyle = `rgba(52, 94, 130, ${alpha})`;
          ctx.fill();
          ctx.rotate(-v.heading);

          // 文本标签
          if (alpha > 0.3) {
            ctx.fillStyle = `rgba(52, 94, 130, ${alpha})`;
            ctx.font = '9px monospace';
            ctx.fillText(`${v.id} (${v.speed}km/h)`, 8, -4);
          }

          ctx.restore();
        });
      }
    }

    // 启动雷达
    new RadarDisplay('radar', 560, 200);
  </script>
</body>
</html>

八、工程实践与性能优化总结

在工业级看板或高负载车载大屏场景下,如果页面同时运行其他 3D 渲染器、地图切片或频繁的 WebSocket 遥测通信,Canvas 的绘制效率必须精打细算。

JavaScript Canvas绘制雷达扫描动画及车辆标记实现
图 5:雷达监控系统分层架构与生产级性能工程优化总结

结合实际工程落地经验,有以下三个关键优化准则:

优化维度 常见性能瓶颈 工程解决方案与实施做法
静态背景离屏缓存 每帧重复计算十多次同心圆弧和虚线,占用大量 CPU 绘图指令。 使用 document.createElement('canvas') 创建同尺寸离屏画板,只在初始化或尺寸改变时绘制一次刻度底盘。主循环中直接使用 ctx.drawImage(offscreenCanvas, -center.x, -center.y) 单步拷贝整屏。
刷新率适应性补偿 在 144Hz 电竞屏或 30Hz 节能模式下,如果固定每帧增加定额角度,会导致雷达旋转过快或过慢。 必须使用 deltaTime = (now - lastTimestamp) / 1000 进行时间积分(angle += speed * deltaTime),确保无论帧率波动多大,物理旋转速度始终保持恒定。
垃圾回收 (GC) 停顿规避 在 requestAnimationFrame 循环内频繁构造临时对象 { x, y } 或临时闭包,引发频繁 Minor GC 卡顿。 采用对象池(Object Pool)或类属性复用机制,数学投影计算直接就地写入数字变量,杜绝每帧生成短命对象。

通过遵循上述分层架构与极坐标投影模型,无论是针对模拟车辆、实际 GPS 轨迹还是激光雷达点云,开发者均可在 HTML5 Canvas 上构建出既有严谨工程数据准确度、又具流畅视觉冲击力的专业雷达扫描追踪界面。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章