抽稀（Data Decimation）是一种数据压缩技术，用于减少数据点的数量同时保持数据的主要特征。下面介绍几种常用的抽稀算法：

1. 等距抽稀（Uniform Decimation）

最简单的抽稀方法，每隔固定间隔选择一个数据点。

// 等距抽稀
func uniformDecimation(data []float64, factor int) []float64 {
    if factor <= 1 {
        return data
    }
    
    result := make([]float64, 0, len(data)/factor+1)
    for i := 0; i < len(data); i += factor {
        result = append(result, data[i])
    }
    return result
}

2. Douglas-Peucker 算法

最常用的抽稀算法之一，通过递归方式保留关键点。

// Douglas-Peucker 算法实现
type Point struct {
    X float64 // 时间戳
    Y float64 // 数值
}

func douglasPeucker(points []Point, epsilon float64) []Point {
    if len(points) <= 2 {
        return points
    }
    
    // 找到最大距离点
    maxDist := 0.0
    maxIndex := 0
    
    start := points[0]
    end := points[len(points)-1]
    
    for i := 1; i < len(points)-1; i++ {
        dist := perpendicularDistance(points[i], start, end)
        if dist > maxDist {
            maxDist = dist
            maxIndex = i
        }
    }
    
    // 如果最大距离小于阈值，直接返回起点和终点
    if maxDist < epsilon {
        return []Point{start, end}
    }
    
    // 递归处理左右两部分
    left := douglasPeucker(points[:maxIndex+1], epsilon)
    right := douglasPeucker(points[maxIndex:], epsilon)
    
    // 合并结果（去除重复点）
    return append(left[:len(left)-1], right...)
}

// 计算点到线段的垂直距离
func perpendicularDistance(point, start, end Point) float64 {
    if start.X == end.X {
        return math.Abs(point.X - start.X)
    }
    
    slope := (end.Y - start.Y) / (end.X - start.X)
    intercept := start.Y - slope*start.X
    
    // 点到直线距离公式
    return math.Abs(slope*point.X-point.Y+intercept) / math.Sqrt(slope*slope+1)
}

3. Ramer-Douglas-Peucker 算法的实际应用

结合时间序列数据的具体实现：

// TimeSeriesPoint 表示时间序列中的一个数据点
type TimeSeriesPoint struct {
    Timestamp float64
    Value     float64
}

// TimeSeriesDecimator 时间序列抽稀器
type TimeSeriesDecimator struct {
    epsilon     float64  // 抽稀阈值
    maxPoints   int      // 最大保留点数
    windowSize  int      // 滑动窗口大小
}

func NewTimeSeriesDecimator(epsilon float64, maxPoints, windowSize int) *TimeSeriesDecimator {
    return &TimeSeriesDecimator{
        epsilon:    epsilon,
        maxPoints:  maxPoints,
        windowSize: windowSize,
    }
}

// Decimate 执行时间序列抽稀
func (d *TimeSeriesDecimator) Decimate(data []TimeSeriesPoint) []TimeSeriesPoint {
    if len(data) <= d.maxPoints {
        return data
    }
    
    // 转换为Point格式
    points := make([]Point, len(data))
    for i, p := range data {
        points[i] = Point{X: p.Timestamp, Y: p.Value}
    }
    
    // 使用Douglas-Peucker算法抽稀
    decimated := douglasPeucker(points, d.epsilon)
    
    // 转换回TimeSeriesPoint格式
    result := make([]TimeSeriesPoint, len(decimated))
    for i, p := range decimated {
        result[i] = TimeSeriesPoint{
            Timestamp: p.X,
            Value:    p.Y,
        }
    }
    
    return result
}

// 实际使用示例
func processSensorData(sensorData []TimeSeriesPoint) []TimeSeriesPoint {
    decimator := NewTimeSeriesDecimator(
        0.1,    // epsilon: 允许的最大误差
        1000,   // maxPoints: 最大保留点数
        5000,   // windowSize: 滑动窗口大小
    )
    
    return decimator.Decimate(sensorData)
}

4. 滑动窗口平均抽稀

通过计算窗口内的平均值来减少数据点：

// 滑动窗口平均抽稀
func windowedMeanDecimation(data []float64, windowSize int) []float64 {
    if windowSize <= 1 {
        return data
    }
    
    result := make([]float64, 0, len(data)/windowSize+1)
    
    for i := 0; i < len(data); i += windowSize {
        end := i + windowSize
        if end > len(data) {
            end = len(data)
        }
        
        // 计算窗口内平均值
        sum := 0.0
        count := 0
        for j := i; j < end; j++ {
            sum += data[j]
            count++
        }
        
        result = append(result, sum/float64(count))
    }
    
    return result
}

5. 基于重要性的抽稀

根据数据点的重要性进行选择：

// 重要性计算函数
func calculateImportance(prev, curr, next float64) float64 {
    // 计算点的曲率或其他重要性指标
    return math.Abs(prev - 2*curr + next)
}

// 基于重要性的抽稀
func importanceBasedDecimation(data []float64, targetPoints int) []float64 {
    if len(data) <= targetPoints {
        return data
    }
    
    // 计算每个点的重要性
    importance := make([]struct {
        index float64
        value float64
    }, len(data)-2)
    
    for i := 1; i < len(data)-1; i++ {
        importance[i-1] = struct {
            index float64
            value float64
        }{
            float64(i),
            calculateImportance(data[i-1], data[i], data[i+1]),
        }
    }
    
    // 按重要性排序
    sort.Slice(importance, func(i, j int) bool {
        return importance[i].value > importance[j].value
    })
    
    // 选择最重要的点
    selectedIndices := make(map[int]bool)
    selectedIndices[0] = true                // 保留起点
    selectedIndices[len(data)-1] = true     // 保留终点
    
    for i := 0; i < targetPoints-2 && i < len(importance); i++ {
        idx := int(importance[i].index)
        selectedIndices[idx] = true
    }
    
    // 构建结果
    result := make([]float64, 0, targetPoints)
    for i := 0; i < len(data); i++ {
        if selectedIndices[i] {
            result = append(result, data[i])
        }
    }
    
    return result
}

6. 完整的抽稀管理器

// DecimationManager 抽稀管理器
type DecimationManager struct {
    uniformDecimator    *UniformDecimator
    douglasPeucker      *DouglasPeuckerDecimator
    windowedMean        *WindowedMeanDecimator
    importanceBased     *ImportanceBasedDecimator
}

func NewDecimationManager() *DecimationManager {
    return &DecimationManager{
        uniformDecimator:    NewUniformDecimator(),
        douglasPeucker:      NewDouglasPeuckerDecimator(0.1),
        windowedMean:        NewWindowedMeanDecimator(10),
        importanceBased:     NewImportanceBasedDecimator(1000),
    }
}

// DecimateData 根据不同策略进行抽稀
func (dm *DecimationManager) DecimateData(data []float64, strategy string) []float64 {
    switch strategy {
    case "uniform":
        return dm.uniformDecimator.Decimate(data)
    case "douglas-peucker":
        return dm.douglasPeucker.Decimate(data)
    case "windowed-mean":
        return dm.windowedMean.Decimate(data)
    case "importance":
        return dm.importanceBased.Decimate(data)
    default:
        return data
    }
}

// 使用示例
func processTimeSeriesData(data []float64) {
    manager := NewDecimationManager()
    
    // 根据数据量选择合适的抽稀策略
    var decimated []float64
    if len(data) > 10000 {
        decimated = manager.DecimateData(data, "douglas-peucker")
    } else if len(data) > 5000 {
        decimated = manager.DecimateData(data, "windowed-mean")
    } else if len(data) > 1000 {
        decimated = manager.DecimateData(data, "uniform")
    } else {
        decimated = data
    }
    
    // 处理抽稀后的数据...
}

这些抽稀算法各有特点：

1. 等距抽稀：

   • 优点：实现简单，计算速度快
   • 缺点：可能丢失重要特征
   • 适用：数据变化平缓的场景

2. Douglas-Peucker算法：

   • 优点：保留数据的关键特征点
   • 缺点：计算复杂度较高
   • 适用：需要保留数据形状特征的场景

3. 滑动窗口平均：

   • 优点：可以平滑噪声
   • 缺点：可能模糊突变特征
   • 适用：含有噪声的数据

4. 基于重要性：

   • 优点：可以保留关键变化点
   • 缺点：需要定义合适的重要性度量
   • 适用：需要保留特定特征的场景

选择合适的抽稀算法需要考虑：

1. 数据特征（平滑/突变）
2. 性能要求
3. 精度要求
4. 存储限制

建议根据实际应用场景选择合适的抽稀策略，必要时可以组合多种策略使用。