概述

相信大家在开车导航时都注意到了，高德地图（以及其他导航软件）现在能在路口精准地显示红绿灯的倒计时，甚至还能告诉你“需要等待 2 轮红灯”。

很多人第一反应是：“高德是不是接入了交警的红绿灯后台数据？”

答案是：极少部分是接入的，绝大部分是“算”出来的。

如果全靠接入，考虑到全国各地红绿灯系统的封闭性、多样性和数据安全，这几乎是不可能完成的任务。实际上，高德是利用海量的用户轨迹数据，通过算法反向推演出红绿灯的周期。这其中的核心技术，参考了其公开的专利 CN114463969A（红绿灯周期时长的挖掘方法）。

今天我们就来硬核拆解一下，这个“读心术”是如何实现的。

核心原理

通俗的讲，红绿灯的本质是一个周期性函数。只要我们观察到足够多的样本，就能拟合出这个函数。

想象一下，你站在路口，虽然看不见红绿灯，但你发现：

每隔 60 秒，就有一大波车停下来（红灯）。
每隔 60 秒，又有一大波车同时起步（绿灯）。

高德做的就是这个“观察者”。它利用海量的用户手机 GPS 数据，分析车辆在路口的 “停车-起步” 行为，进而推算出红绿灯的 周期时长 和 红绿相位。

这个过程主要分为三个核心步骤：

样本筛选：找到经过该路口的车辆轨迹。
起停波识别：识别车辆何时停车，何时起步。
周期挖掘：通过起步时间的规律，算出红绿灯周期。

参考专利地址：CN114463969A – Method and apparatus for mining traffic signal light cycle

实现细节

1. 数据清洗与事件提取

并不是所有经过路口的轨迹都有用。我们需要筛选出“受红绿灯影响”的轨迹。

有效样本：在路口前速度降为 0，且停留超过一定时间，然后加速通过的车辆。
无效样本：直接绿灯通过的车辆（没有停车特征，无法判断红灯起始点），或者右转车辆（通常不受红绿灯限制）。

对于每一辆有效车辆 i，我们可以提取出一个关键事件：起步时间 t_start。
这个 t_start 近似等于绿灯亮起的时间（当然有延迟，后面会说怎么校准）。

2. 聚类形成“起步波”

单个车辆的数据可能存在误差（比如司机走神了，绿灯亮了 3 秒才走）。但如果有 10 辆车在 10:00:05 ~ 10:00:10 之间起步，我们就可以认为这是一个 “绿灯起步波”。

我们需要将时间轴上离散的起步点，聚合为一个个簇（Cluster）。

3. 周期计算 (核心数学逻辑)

假设红绿灯周期是 T。那么理想情况下，所有“起步波”的时间差应该是 T 的整数倍。
例如：

第一波起步：10:00:00
第二波起步：10:02:00 (间隔 120s)
第三波起步：10:03:00 (间隔 60s)

可以推断，周期 T 很有可能是 60s（因为 120 和 60 都是 60 的倍数）。

算法会尝试搜索一个最佳的 T，使得所有观测到的起步时间 t 满足以下公式：

t ≈ t_base + k * T + error

其中：

t_base 是基准时间
k 是整数轮次
error 是误差

4. 误差修正（排队论）

这是最难的一点。车辆起步时间 != 绿灯亮起时间。
如果一辆车排在第 10 位，它起步的时间可能比绿灯亮起晚 20 秒。

高德的算法会考虑 排队位置。通过 GPS 坐标，可以算出车辆距离停车线的距离。

修正后的绿灯时间 = 实际起步时间 - (排队距离 / 饱和流率)

Golang 代码示例

下面用一段 Go 代码来模拟这个“周期挖掘”的核心逻辑。为了简化，我们假设已经提取到了车辆的起步时间列表。(这个代码只是表达思路使用, 与实际无关)

package main

import (
    "fmt"
    "math"
    "sort"
)

// TrafficLightMiner 模拟红绿灯挖掘器
type TrafficLightMiner struct {
    StartTimes []int64 // 收集到的车辆起步时间戳（秒）
}

// AddTrajectory 添加一条轨迹的起步时间
func (m *TrafficLightMiner) AddTrajectory(startTime int64) {
    m.StartTimes = append(m.StartTimes, startTime)
}

// CalculateCycle 挖掘红绿灯周期
// 原理：寻找一个周期 T，使得绝大多数的时间间隔都是 T 的整数倍
func (m *TrafficLightMiner) CalculateCycle() int {
    if len(m.StartTimes) < 2 {
        return 0
    }

    // 1. 先对时间进行排序
    sort.Slice(m.StartTimes, func(i, j int) bool {
        return m.StartTimes[i] < m.StartTimes[j]
    })

    // 2. 计算相邻起步波的时间差 (Diff)
    // 在实际场景中，这里需要先做聚类，把同一轮红绿灯的车归为一组，取中位数作为该轮的起步时间
    // 这里为了简化，假设输入已经是经过聚类处理后的每轮首车起步时间
    var diffs []int64
    for i := 1; i < len(m.StartTimes); i++ {
        diff := m.StartTimes[i] - m.StartTimes[i-1]
        diffs = append(diffs, diff)
    }

    // 3. 寻找众数或者最大公约数思想的拟合
    // 常见的红绿灯周期通常在 30s - 180s 之间
    // 我们尝试在这个范围内搜索得分最高的周期
    bestCycle := 0
    maxScore := 0.0

    for t := 30; t <= 180; t++ {
        score := m.evaluateCycle(t, diffs)
        if score > maxScore {
            maxScore = score
            bestCycle = t
        }
    }

    return bestCycle
}

// evaluateCycle 评分函数：计算某个周期 T 对数据的解释程度
func (m *TrafficLightMiner) evaluateCycle(T int, diffs []int64) float64 {
    hits := 0.0
    tolerance := 3.0 // 容忍误差 3秒

    for _, diff := range diffs {
        // 计算 diff 是否是 T 的倍数
        // 例如 diff = 122, T = 60, remainder = 2 (在误差允许范围内)
        remainder := math.Mod(float64(diff), float64(T))

        // 处理余数接近 T 的情况 (例如余数 59 相当于 -1)
        if remainder > float64(T)/2 {
            remainder = float64(T) - remainder
        }

        if remainder <= tolerance {
            hits++
        }
    }

    // 返回命中率
    return hits / float64(len(diffs))
}

func main() {
    miner := TrafficLightMiner{}

    // 模拟数据：假设红绿灯周期是 60秒
    // 车辆分别在以下时间点起步 (包含一些随机误差和跳过的轮次)
    // 第1轮: 100s
    // 第2轮: 161s (误差+1s)
    // 第3轮: 没有车通过 (跳过)
    // 第4轮: 280s (100 + 60*3 = 280)
    // 第5轮: 342s (100 + 60*4 + 误差2s)

    simulatedData := []int64{100, 161, 280, 342, 400, 521}

    for _, t := range simulatedData {
        miner.AddTrajectory(t)
    }

    cycle := miner.CalculateCycle()

    fmt.Println("分析样本起步时间:", simulatedData)
    fmt.Printf("计算出的红绿灯周期为: %d 秒\n", cycle)

    // 实际应用中，算出周期后，还需要算出“红灯开始时间”和“偏移量”才能做倒计时
}