下面给你一个基于摘要的一站式雷达试验数据处理系统的毕业设计大纲（系统功能大纲 + 论文/文档大纲都能直接用），并列出实现过程中常用的技术选型。你可以按自己的工作量删减模块。

---

一、系统总体目标与范围

目标：面向雷达试验数据，实现“采集 → 解析 → 清洗/标注 → 滤波/下采样等处理 → 版本化管理 → 降维可视化展示”的一站式平台。
数据来源：多格式离线文件 + UDP实时数据流。

---

二、系统功能大纲（按模块划分）

1）用户与权限模块（可选但很加分）

• 登录/退出、用户管理
• 角色权限（管理员/普通用户/只读）
• 操作审计（谁在什么时候处理了哪份数据）

2）数据采集模块

2.1 离线文件导入

• 自动识别文件格式（按扩展名/魔数/头字段）
• 多格式解析：CSV/JSON/Excel/二进制自定义格式/文本日志等（你可挑2~3种实现）
• 批量上传、断点续传（可选）

2.2 UDP实时接收

• UDP端口监听、报文解析
• 缓冲队列（防止突发丢包/阻塞）
• 实时入库/落盘（原始数据保存）

3）数据管理模块

• 数据集/试验批次管理（按试验编号、雷达型号、时间、场景等元数据）
• 原始数据存档（不可变）
• 数据预览（字段、样本行、缺失率、统计摘要）
• 数据检索/筛选（按时间区间、型号、批次、标签等）

4）数据清洗与标注模块

• 无效数据识别（阈值规则、范围校验、异常点检测等）
• 手动标注（点选/框选/区间标注）
• 标签体系管理（标签类别、说明、颜色等）
• 标注结果与数据集绑定、可导出

5）数据处理模块（核心）

按摘要里提到的能力组织成“处理流水线/工艺链”会很像工程系统：

5.1 统计滤波

• 均值/中值/滑动窗口统计
• 异常值抑制（3σ、IQR 等）

5.2 半径滤波（邻域/半径去噪）

• 在特征空间设定半径 r，保留邻域内点/剔除孤立点（类似密度过滤思路）

5.3 最小距离滤波

• 基于最近邻距离阈值，识别离群点
• 可用 KD-Tree/ BallTree 提速（看数据量）

5.4 下采样

• 等间隔采样、随机采样
• 分层采样（按标签比例保持分布）
• 可选：滑窗聚合降采样（每窗口取均值/最大值）

5.5 处理参数配置与复现

• 每次处理记录：算法、参数、输入数据版本、输出版本、操作者、时间
• 支持“一键复现”同样结果（毕业设计展示很强）

6）数据版本化管理模块

• 原始版本 v0（只读）
• 处理版本 v1/v2…（每次处理生成新版本）
• 版本差异概览（数据量变化、无效点数量、标签数量变化）
• 回滚/对比（可选）

7）可视化与降维展示模块

7.1 常规图表

• 折线图/散点图/直方图/箱线图（展示滤波前后对比、异常点分布等）

7.2 降维可视化

• PCA（最易实现、解释性强）
• t-SNE 或 UMAP（可选，展示更漂亮）
• 支持按标签上色、悬浮提示、框选联动

摘要提到 JFreeChart 做展示：如果你前端也要交互强，建议前端用 ECharts/Chart.js，后端保留 JFreeChart 用于生成报表图（PNG/PDF）也很合理。

8）报表与导出模块（很适合答辩）

• 导出处理后的数据（CSV/Excel/JSON）
• 导出图表（PNG）
• 导出试验处理报告（PDF/Word：包含参数、统计指标、关键图）

9）系统运维与部署模块（可选）

• 日志与异常告警
• 配置中心（端口、存储路径、阈值默认值）
• Docker 部署（加分项）

---

三、推荐的技术栈清单（按前后端/数据/算法）

1）后端（Spring Boot）

• Spring Boot：REST API、工程结构
• Spring MVC：接口层
• Spring Validation：参数校验
• Spring Security + JWT：登录鉴权（可选但推荐）
• MyBatis-Plus / JPA：ORM（二选一）
• 数据库：MySQL / PostgreSQL（二选一）
• 缓存：Redis（可选，用于会话、任务状态、热点数据）
• 文件存储：本地文件系统 / MinIO（可选）
• 实时接收：Java UDP（DatagramSocket / Netty UDP）
• 异步任务：@Async + 线程池 / Spring Batch（可选）
• 日志：SLF4J + Logback

2）前端（Vue）

• Vue 2/3（摘要写 vue，建议 Vue3 更现代）
• Vite / Vue CLI：构建工具
• Element Plus / Ant Design Vue：后台管理 UI
• Axios：请求
• ECharts：交互式可视化（强烈推荐）
• WebSocket / SSE（可选）：实时数据显示（如果你要展示 UDP 实时流）

3）数据解析与处理（Java 侧常用库）

• CSV：OpenCSV / Apache Commons CSV
• Excel：Apache POI
• JSON：Jackson
• 数值计算/矩阵：EJML / Apache Commons Math
• 近邻搜索（可选）：自己实现 KD-Tree 或用现成算法库
• JFreeChart：图表生成（服务端生成 PNG/PDF 图）

4）降维算法（选型建议）

• PCA：用 Commons Math / EJML 实现（毕业设计足够）
• t-SNE/UMAP：Java 实现库较杂；也可“后端算好坐标→前端画散点”
• 如果你允许用 Python：后端调用 Python 脚本做降维（展示效果好，但系统复杂度更高）

5）工程与质量（加分项）

• Swagger / OpenAPI：接口文档
• 单元测试：JUnit5 + Mockito
• 性能压测：JMeter（可选）
• Docker Compose：一键部署（可选）

---

四、论文/毕业设计文档大纲（直接可套用）

1. 绪论（背景、意义、国内外现状、本文工作）
2. 需求分析（业务流程、功能需求、非功能需求、数据格式问题）
3. 总体设计（架构、模块划分、流程设计、数据库设计）
4. 数据采集与解析实现（文件识别、解析器、UDP接收）
5. 数据处理算法设计与实现（统计滤波/半径滤波/最小距离/下采样、参数管理、流水线）
6. 数据版本化与可追溯机制（版本模型、差异统计、回滚/对比）
7. 可视化与降维展示实现（JFreeChart/ECharts、PCA/t-SNE、交互设计）
8. 测试与结果分析（功能测试、性能测试、示例数据处理前后对比）
9. 总结与展望

---

如果你愿意，我也可以把上面模块进一步细化成：

• 数据库表设计（ER图/字段建议）
• 关键接口清单（REST API 列表）
• 处理流水线的类设计（策略模式/责任链）
  直接让你按图施工写代码。你打算主要处理的数据格式是什么（CSV/Excel/自定义二进制/日志）以及数据量大概多大？

下面给你一套能直接开干的实现方案，只覆盖你说的三个模块：** 数据采集 / 数据处理 / 数据可视化**。我按“总体架构 → 数据流 → 后端实现细节（类/表/接口）→ 前端实现细节 → 关键算法落地”来写，你照着做基本就能完成毕业设计并且好答辩。

---

0. 总体架构与数据流

技术建议

• 后端：Spring Boot + MySQL（或 PostgreSQL）+ MyBatis-Plus/JPA + Redis（可选）
• 前端：Vue3 + Element Plus + ECharts
• 图表导出：JFreeChart（后端生成 PNG/PDF 报表图）
• 文件：本地存储（开发快）或 MinIO（加分）

核心数据流（统一成“数据集 Dataset + 版本 Version”）

1. 采集：上传文件 / UDP 实时 → 落盘原始数据 → 入库元数据 → 生成 Version v0(原始)
2. 处理：选择 v0 或某版本 → 配置处理流水线（参数）→ 异步执行 → 生成 Version v1/v2…
3. 可视化：选某版本 → 读取样本/统计/降维结果 → ECharts 展示；需要导出时调用 JFreeChart 生成图片/报告

---

1) 数据采集模块实现方案

1.1 离线文件导入（多格式自动识别 + 统一入库）

A. 支持的文件格式（建议你毕业设计先做这三种）

• CSV（最常见）
• Excel（.xlsx）
• JSON（数组或逐行 JSON）

B. 关键设计：统一“解析成同一条样本结构”

把任何格式都解析成统一的 SampleRecord（Map/JSON 形式），避免你后面处理逻辑写三套。

SampleRecord（建议）

• ts：时间戳（毫秒或微秒）
• features：数值特征（比如距离/速度/方位/幅度等）
• meta：补充字段（雷达型号、通道号、批次号等）
• valid：是否有效（默认 true）

你不需要一开始就固定字段很死，先用“动态字段 + 字段映射表”更适合摘要里的“格式不统一”。

C. 后端实现步骤

1. 前端上传文件：POST /api/ingest/file（multipart）
2. 后端保存文件到：/data/raw/{datasetId}/{fileId}/xxx
3. 进行格式识别：
   • 优先按扩展名
   • 失败再读前几 KB 判断（CSV 常见是文本+逗号；JSON 以 { 或 [ 开始；XLSX 是 zip 头）
4. 选择对应 Parser：
   • CsvParser（Apache Commons CSV / OpenCSV）
   • ExcelParser（Apache POI）
   • JsonParser（Jackson）
5. 解析出来的记录批量写入“原始样本表”或“原始文件+行存储”（见下面存储建议）
6. 创建 Version v0，记录：输入文件、字段映射、样本数量、缺失率等摘要统计

D. 存储方案（两种，你二选一）

方案1：MySQL 直接存样本（适合数据量不大，开发简单）

• sample_record 表：id, version_id, ts, data_json, valid
• 优点：查询方便、实现快
• 缺点：数据量大时性能一般

方案2：样本落盘为 Parquet/CSV + DB 存索引（适合数据量较大，加分）

• 原始解析后写到：/data/version/{versionId}/data.csv 或 parquet
• DB 存：文件路径、行数、字段列表、统计
• 优点：大数据更稳
• 缺点：你要写读取抽象（但也不难）

毕设一般我建议方案1，除非你明确数据量上百万行以上。

---

1.2 UDP 实时采集（接收 → 缓冲 → 落盘/入库）

A. 关键点（答辩时很好讲）

• UDP 不可靠：要缓冲队列，避免写库阻塞导致丢包
• 需要“会话/批次”：把一段时间的 UDP 数据归档成一个 dataset/version

B. 后端实现结构

• UdpReceiver：DatagramSocket/Netty 监听端口
• BlockingQueue<UdpPacket>：接收线程只负责入队
• UdpConsumerWorker（1~N 个）：从队列取包 → 解析 → 写入存储（批量）
• UdpSessionManager：管理当前“采集会话”（开始/停止/超时）

C. UDP 报文解析策略

• 如果你有固定报文格式：写 UdpBinaryDecoder
• 如果没有：你可以把 UDP 当“行文本/JSON”：
  • 每包是一行 CSV
  • 或每包一条 JSON（最简单）

D. 接口建议

• POST /api/ingest/udp/start（参数：端口、会话名、持续时间/停止条件）
• POST /api/ingest/udp/stop
• GET /api/ingest/udp/status（队列长度、接收速率、丢包估计、已写入条数）

---

2) 数据处理模块实现方案（流水线 + 版本化 + 异步任务）

2.1 核心概念：处理流水线 Pipeline

你要把“统计滤波 / 半径滤波 / 最小距离滤波 / 下采样”做成可组合的步骤：

• Pipeline = Step1 -> Step2 -> ... -> StepN
• 每一步都有：name、参数、输入version、输出version、日志、统计

A. 后端类设计（够具体）

• ProcessingStep（接口）
  • StepResult apply(SampleReader reader, StepContext ctx)
• 具体实现：
  • StatFilterStep
  • RadiusFilterStep
  • MinDistanceFilterStep
  • DownsampleStep
• PipelineExecutor
  • 读取输入 version → 依次执行 step → 写出新 version
• SampleReader / SampleWriter
  • 屏蔽你底层是 DB 还是文件
• VersionService
  • 创建新版本、记录参数、统计、路径

B. 异步执行（必须做，体验好）

• POST /api/process/run → 返回 jobId
• 后台线程池跑 PipelineExecutor
• GET /api/process/job/{jobId} 查询进度/状态
• 完成后返回新 versionId

实现可以用 @Async + ThreadPoolTaskExecutor，job 状态存 MySQL/Redis 都行。

---

2.2 各算法“怎么落地”（给你可实现的版本）

2.2.1 统计滤波（StatFilter）

用途：平滑噪声、去异常点（按字段）

• 输入参数：
  • field：处理哪个字段（如 range/velocity）
  • windowSize：滑窗大小（如 5/11）
  • mode：mean / median
  • 可选：outlierRule：3sigma / iqr（只做剔除，不替换）
• 实现：
  • 按时间排序
  • 滑动窗口计算均值/中值
  • 若做异常剔除：对窗口内做阈值判断，超出则置 valid=false 或替换为窗口统计值

输出：新版本 + 统计（剔除多少、均方差变化等）

---

2.2.2 半径滤波（RadiusFilter）

用途：剔除“孤立点”（你摘要里那种“半径滤波”）

• 输入参数：
  • fields: 用于计算距离的字段集合（如 [range, azimuth, velocity]）
  • radius r
  • minNeighbors k：半径内至少要有 k 个邻居，否则判为噪声
• 可实现版本（易写）：
  • 对每个点 i，统计与其他点距离 < r 的数量
  • 小数据直接 O(n^2) 就够毕设
• 加速版本（加分，可选）：
  • 用 KD-Tree（二维/三维更好做）做半径查询

输出：标记 valid=false 的点 + 新版本

---

2.2.3 最小距离滤波（MinDistanceFilter）

用途：基于最近邻距离的离群点剔除

• 输入参数：
  • fields
  • distanceThreshold d
  • 或者 topPercent：剔除最近邻距离最大的前 x%
• 实现：
  • 对每个点算最近邻距离 nnDist(i)
  • 若 nnDist(i) > d → invalid
  • 也可用百分位阈值（更稳）

---

2.2.4 下采样（Downsample）

用途：减小数据量、提高可视化性能

• 输入参数：
  • mode: every_n / random / time_bucket
  • n：每 n 取 1
  • bucketMs：按时间分桶聚合（每桶取均值/最大值）
• 实现建议：
  • every_n 最容易
  • time_bucket 最适合雷达时序数据展示（答辩很好讲）

---

2.3 处理参数与版本化（你系统“像工程”的关键）

每次处理生成一条 Version：

• versionId
• parentVersionId
• pipelineJson（步骤+参数）
• createdBy / createdAt
• inputStats / outputStats
• dataPath 或 recordCount

这样你就能做：

• 版本列表（树状）
• 版本对比（处理前后统计+图）
• 一键复现（拿 pipelineJson 再跑一次）

---

3) 数据可视化模块实现方案（ECharts + 降维 + JFreeChart 导出）

3.1 前端展示页面结构（建议你就按这个做）

1. 数据集/版本选择页
2. 版本详情页（统计卡片 + 图表区）
3. 处理页（选择步骤、填参数、运行任务、进度条）
4. 降维可视化页（PCA / t-SNE 可选）
5. 报表导出页（可合并到详情页）

---

3.2 图表与接口设计（务实好实现）

A. 统计概览接口（卡片用）

• GET /api/version/{id}/summary 返回：
• 总点数、有效点数、无效点数
• 缺失率（按字段）
• 字段 min/max/mean/std（选 3~5 个关键字段）

B. 折线/散点接口（时序/关系图）

• GET /api/version/{id}/samples?fields=ts,range,velocity&limit=5000 返回：
• 若数据太多，后端直接做下采样再返回（比如默认最多 5000 点）
• 前端用 ECharts：
  • ts-range 折线图
  • range-velocity 散点图
  • 有效/无效点用不同系列（或不同标记）

C. 分布图接口（直方图/箱线图）

• GET /api/version/{id}/hist?field=range&bins=50 后端返回 bins 统计，前端画直方图

---

3.3 降维可视化（PCA 最推荐，稳）

A. 后端计算 PCA（建议离线算并缓存到版本里）

• POST /api/version/{id}/pca 参数：
• fields=[range, velocity, azimuth, snr]
• dim=2 后端：
• 从 version 读取有效点
• 标准化（均值方差归一）
• PCA 得到 2D 坐标
• 保存结果：/data/version/{id}/pca_2d.json 或表 dim_result

B. 前端展示

• GET /api/version/{id}/pca/result 返回二维点：
• x, y, label, valid ECharts scatter：
• 按 label 上色（如果你做了标注）
• 鼠标 hover 显示原始字段（tooltip）

t-SNE/UMAP 如果你想做，可以放成“可选增强功能”，但 PCA 足够完成摘要里的“降维展示”。

---

3.4 JFreeChart（用于导出图片/报告，加分）

前端点“导出报告”：

• POST /api/report/version/{id} 后端用 JFreeChart 生成：
• 滤波前后对比图（折线/散点）
• 直方图（range 分布）
• PCA 散点图（如果有） 然后打包成：
• PNG 文件 + PDF（可选） 返回下载地址。

---

4) 最小可交付版本（MVP）建议（保证你能按时完成）

如果时间紧，就按这个做：

1. 采集：CSV 上传 + UDP（每包一条 JSON）
2. 处理：统计滤波（滑窗均值）+ 下采样（every_n）
3. 可视化：折线图 + 散点图 + 直方图 + PCA（2D）
4. 版本化：v0、v1、v2… + pipelineJson 可追溯
5. 导出：导出处理后 CSV（图表导出可选）

---

如果你告诉我两点信息，我可以把接口、表结构、以及每个 step 的参数 JSON 直接给你定死到“可复制进代码”的程度：

1. 你的数据字段大概有哪些（比如 range/velocity/azimuth/snr/…）？
2. 数据规模大概是：几万条 / 几十万条 / 上百万条？

下面我按你摘要里提到的 4 个处理算法（统计滤波 / 半径滤波 / 最小距离滤波 / 下采样）给出Java 可直接落地的实现思路 + 可用代码骨架。默认你数据已经解析成一组“样本点”，每个点有若干数值字段（range/velocity/azimuth…）和一个 valid 标记。

---

0）统一数据结构（建议你先这么建模）

java
import java.util.*;

public class SamplePoint {
    public long ts;                     // 时间戳，可选
    public Map<String, Double> f;        // 动态数值特征：field -> value
    public boolean valid = true;         // 是否有效（被滤除则置 false）
    public String label;                 // 可选：人工标注标签

    public SamplePoint(long ts, Map<String, Double> f) {
        this.ts = ts;
        this.f = f;
    }

    public Double get(String key) { return f.get(key); }
    public void set(String key, double v) { f.put(key, v); }
}

一些通用工具函数（距离/取字段向量）：

java
public class MathUtil {
    public static double euclidean(SamplePoint a, SamplePoint b, List<String> fields) {
        double s = 0.0;
        for (String k : fields) {
            double va = a.get(k);
            double vb = b.get(k);
            double d = va - vb;
            s += d * d;
        }
        return Math.sqrt(s);
    }
}

---

1）统计滤波（滑动窗口均值/中值）

1.1 滑动均值（Moving Average）

适合时序信号平滑。实现要点：

• 先按 ts 排序
• 只对 valid=true 的点参与统计（你也可以都参与）
• 用前缀和做到 O(n)

java
import java.util.*;

public class StatFilters {

    // 对 field 做滑窗均值平滑：windowSize 必须为奇数更直观（比如 5/11）
    public static void movingAverage(List<SamplePoint> pts, String field, int windowSize) {
        pts.sort(Comparator.comparingLong(p -> p.ts));

        int n = pts.size();
        double[] x = new double[n];
        for (int i = 0; i < n; i++) x[i] = pts.get(i).get(field);

        double[] prefix = new double[n + 1];
        for (int i = 0; i < n; i++) prefix[i + 1] = prefix[i] + x[i];

        int half = windowSize / 2;
        for (int i = 0; i < n; i++) {
            int l = Math.max(0, i - half);
            int r = Math.min(n - 1, i + half);
            double sum = prefix[r + 1] - prefix[l];
            double mean = sum / (r - l + 1);
            pts.get(i).set(field, mean);
        }
    }
}

1.2 滑动中值（Moving Median）

中值对尖峰噪声更稳，但朴素实现 O(n·w log w) 也够毕设（窗口一般不大）。

java
public static void movingMedian(List<SamplePoint> pts, String field, int windowSize) {
    pts.sort(Comparator.comparingLong(p -> p.ts));
    int n = pts.size();
    int half = windowSize / 2;

    for (int i = 0; i < n; i++) {
        int l = Math.max(0, i - half);
        int r = Math.min(n - 1, i + half);

        double[] win = new double[r - l + 1];
        for (int j = l; j <= r; j++) win[j - l] = pts.get(j).get(field);
        Arrays.sort(win);
        double med = win[win.length / 2];
        pts.get(i).set(field, med);
    }
}

---

2）半径滤波（Radius Filter：邻域内点数不足则判噪声）

定义：对点 i，统计距离 < r 的邻居数（不含自身也行），若 < minNeighbors 则 valid=false。

朴素 O(n²) 实现最直观、最好写，数据量到几万可能慢；毕设一般 OK。想加速再上 KD-Tree（后面给建议）。

java
import java.util.*;

public class RadiusFilter {

    public static int apply(List<SamplePoint> pts, List<String> fields, double radius, int minNeighbors) {
        int n = pts.size();
        int removed = 0;
        boolean[] keep = new boolean[n];
        Arrays.fill(keep, true);

        for (int i = 0; i < n; i++) {
            if (!pts.get(i).valid) { keep[i] = false; continue; }

            int cnt = 0;
            for (int j = 0; j < n; j++) {
                if (i == j) continue;
                if (!pts.get(j).valid) continue;
                double d = MathUtil.euclidean(pts.get(i), pts.get(j), fields);
                if (d < radius) cnt++;
                if (cnt >= minNeighbors) break;
            }
            if (cnt < minNeighbors) keep[i] = false;
        }

        for (int i = 0; i < n; i++) {
            if (!keep[i] && pts.get(i).valid) {
                pts.get(i).valid = false;
                removed++;
            }
        }
        return removed;
    }
}

参数怎么选（答辩能讲）

• radius：按你字段量纲决定，建议先做标准化（例如各字段 z-score），这样 radius 更好设（如 0.5~2.0）。
• minNeighbors：一般 3~10。

---

3）最小距离滤波（Min Distance / 最近邻距离阈值）

定义：对每个点 i，计算其最近邻距离 nnDist(i)；若 nnDist(i) > threshold 则认为是离群点。

朴素 O(n²)：

java
import java.util.*;

public class MinDistanceFilter {

    public static int apply(List<SamplePoint> pts, List<String> fields, double threshold) {
        int n = pts.size();
        double[] nn = new double[n];
        Arrays.fill(nn, Double.POSITIVE_INFINITY);

        for (int i = 0; i < n; i++) {
            if (!pts.get(i).valid) continue;
            for (int j = 0; j < n; j++) {
                if (i == j) continue;
                if (!pts.get(j).valid) continue;
                double d = MathUtil.euclidean(pts.get(i), pts.get(j), fields);
                if (d < nn[i]) nn[i] = d;
            }
        }

        int removed = 0;
        for (int i = 0; i < n; i++) {
            if (pts.get(i).valid && nn[i] > threshold) {
                pts.get(i).valid = false;
                removed++;
            }
        }
        return removed;
    }

    // 另一种更稳：按百分位阈值剔除，比如剔除 nnDist 最大的 topPercent
    public static int applyTopPercent(List<SamplePoint> pts, List<String> fields, double topPercent) {
        int n = pts.size();
        List<Double> dists = new ArrayList<>();
        double[] nn = new double[n];
        Arrays.fill(nn, Double.POSITIVE_INFINITY);

        for (int i = 0; i < n; i++) {
            if (!pts.get(i).valid) continue;
            for (int j = 0; j < n; j++) {
                if (i == j) continue;
                if (!pts.get(j).valid) continue;
                double d = MathUtil.euclidean(pts.get(i), pts.get(j), fields);
                if (d < nn[i]) nn[i] = d;
            }
            if (Double.isFinite(nn[i])) dists.add(nn[i]);
        }

        dists.sort(Double::compareTo);
        int idx = (int)Math.floor((1.0 - topPercent) * (dists.size() - 1));
        idx = Math.max(0, Math.min(idx, dists.size() - 1));
        double thr = dists.get(idx);

        int removed = 0;
        for (int i = 0; i < n; i++) {
            if (pts.get(i).valid && nn[i] > thr) {
                pts.get(i).valid = false;
                removed++;
            }
        }
        return removed;
    }
}

---

4）下采样（4种常用实现）

4.1 等间隔采样 every_n

java
import java.util.*;

public class Downsample {

    public static List<SamplePoint> everyN(List<SamplePoint> pts, int n) {
        if (n <= 1) return new ArrayList<>(pts);
        List<SamplePoint> out = new ArrayList<>();
        for (int i = 0; i < pts.size(); i++) {
            if (i % n == 0) out.add(pts.get(i));
        }
        return out;
    }
}

4.2 随机采样 random（按比例）

java
public static List<SamplePoint> randomKeep(List<SamplePoint> pts, double keepRate, long seed) {
    Random r = new Random(seed);
    List<SamplePoint> out = new ArrayList<>();
    for (SamplePoint p : pts) {
        if (r.nextDouble() < keepRate) out.add(p);
    }
    return out;
}

4.3 时间分桶（time bucket）——雷达时序很适合

每 bucketMs 一个桶，对桶内字段做均值聚合，输出更平滑、点数更少：

java
public static List<SamplePoint> timeBucketMean(List<SamplePoint> pts, long bucketMs, List<String> fields) {
    pts.sort(Comparator.comparingLong(p -> p.ts));
    List<SamplePoint> out = new ArrayList<>();
    if (pts.isEmpty()) return out;

    long start = pts.get(0).ts;
    long curBucket = start / bucketMs;

    Map<String, Double> sum = new HashMap<>();
    int cnt = 0;
    long bucketTs = pts.get(0).ts;

    for (SamplePoint p : pts) {
        long b = p.ts / bucketMs;
        if (b != curBucket) {
            // flush
            if (cnt > 0) {
                Map<String, Double> feat = new HashMap<>();
                for (String f : fields) feat.put(f, sum.getOrDefault(f, 0.0) / cnt);
                out.add(new SamplePoint(bucketTs, feat));
            }
            // reset
            curBucket = b;
            sum.clear();
            cnt = 0;
            bucketTs = p.ts;
        }
        if (!p.valid) continue;
        for (String f : fields) sum.put(f, sum.getOrDefault(f, 0.0) + p.get(f));
        cnt++;
    }

    if (cnt > 0) {
        Map<String, Double> feat = new HashMap<>();
        for (String f : fields) feat.put(f, sum.getOrDefault(f, 0.0) / cnt);
        out.add(new SamplePoint(bucketTs, feat));
    }
    return out;
}

---

5）工程化建议：把算法做成“Step”可串联（很关键）

一个简单 Step 接口：

java
public interface ProcessingStep {
    String name();
    void apply(List<SamplePoint> points);
}

举例把半径滤波封装：

java
import java.util.*;

public class RadiusFilterStep implements ProcessingStep {
    private final List<String> fields;
    private final double radius;
    private final int minNeighbors;

    public RadiusFilterStep(List<String> fields, double radius, int minNeighbors) {
        this.fields = fields;
        this.radius = radius;
        this.minNeighbors = minNeighbors;
    }

    @Override public String name() { return "radius_filter"; }

    @Override public void apply(List<SamplePoint> points) {
        RadiusFilter.apply(points, fields, radius, minNeighbors);
    }
}

然后 Pipeline：

java
public class Pipeline {
    private final List<ProcessingStep> steps = new ArrayList<>();

    public Pipeline add(ProcessingStep s) { steps.add(s); return this; }

    public void run(List<SamplePoint> pts) {
        for (ProcessingStep s : steps) s.apply(pts);
    }
}

---

6）性能加速怎么讲（可选加分）

如果数据量上来（> 5万点）朴素 O(n²) 会慢，你有两个常见升级路线：

1. 先标准化 + 下采样：先做 time-bucket/ every_n 把点数降下来，再做半径/最近邻（成本最低，工程最常见）。
2. KD-Tree/网格哈希：
   • 2D/3D 用 KD-Tree 做半径查询和最近邻，复杂度能接近 O(n log n)
   • 更简单的实现：把空间按 cellSize=radius 划格子（HashMap<cell, list>），只在邻近格子里找邻居，写起来比 KD-Tree 简单

如果你告诉我你“fields 维度是 2/3 还是更多、数据规模是多少”，我可以把 网格哈希版半径滤波/最近邻 也给你一份完整 Java 实现（非常适合毕设：代码不长、速度提升明显、解释清楚）。

---

你现在的数据特征字段大概有哪些？（比如 range/velocity/azimuth/snr）以及单批次大概多少点（1万/10万/100万）？我好给你把 radius/threshold 的推荐设定方式和“是否需要加速”的实现版本定下来。

下面把“半径滤波 / 最近邻最小距离滤波”在数据量变大时怎么加速讲透，并给你两套很适合 Java 毕设落地的方案（从简单到加分），附关键代码骨架。

---

一、先搞清楚瓶颈：为什么 O(n²) 会爆

半径滤波和最近邻距离滤波，朴素写法都是：

• 对每个点 i，遍历所有点 j，算距离
  👉 距离计算次数 ≈ n(n-1)

当 n=50,000 时，约 25 亿次距离计算，Java 很容易就卡死。

---

二、加速总策略（从工程上最常用的 4 招）

1）先降维/降量：先下采样再做邻域算法（最省事、最工程）

真实系统里常这么做：

• 先 time_bucket / every_n 把点数从 50万降到 5万或更少
• 再做半径滤波、最近邻滤波
• 可视化也只用下采样版本

好处：实现简单、收益巨大；缺点：可能损失细节（但毕设完全可接受）。

2）特征标准化：让 “radius/threshold” 更好设 + 网格更稳定

你用多个字段算欧氏距离时，各字段量纲不同（比如 range=几千，velocity=几十），会导致距离被某一个字段支配。 建议做 z-score：

$$x' = \frac{x-\mu}{\sigma}$$

标准化后：

• radius 可以取 0.5~2.0 这类稳定区间
• 网格 cellSize 的含义更明确
• 阈值/参数解释也更好讲

3）空间索引：只在“附近的候选点”里算距离（核心提速）

两条路：

• 网格哈希（Uniform Grid / Spatial Hash）：实现简单，毕设最推荐
• KD-Tree：更“算法正统”，但实现复杂度更高

4）并行化 + 批处理：CPU 吃满 + 减少数据库/IO开销

• 距离计算是 CPU 密集型，可按点 i 分块并行
• 写库/写文件用 batch（比如 1000/5000 条一批）

---

三、方案 A（强烈推荐毕设用）：网格哈希加速半径滤波/最近邻

3.1 核心思想

把空间按 cellSize 切成很多小格子（cell）。
每个点只和自己所在格子 + 周围相邻格子的点做比较，而不是全量比较。

如果 cellSize = radius：

• 半径查询只需要检查周围 3^d 个格子（d 是维度）
  • 2D：9 个格子
  • 3D：27 个格子
  • 4D：81 个格子（维度越高越不划算，这就是“维度灾难”）

所以网格哈希最适合 2~3 维（雷达数据常拿 range + azimuth + velocity 或 range + doppler）。

---

3.2 实现要点

① 选维度 fields（建议 2~3 个）

例如：

• fields = [range, velocity]（2D，最快）
• 或 fields = [range, azimuth, velocity]（3D）

② 标准化（建议做）

先把参与距离计算的字段标准化后再建网格。

③ cellId 计算

对每个点：

• cellCoord[k] = floor(value[k] / cellSize)
• 多维 cellCoord 组合成 key（字符串/long hash）

---

3.3 Java 代码骨架：网格索引

java
import java.util.*;
import java.util.stream.*;

public class GridIndex {
    private final List<String> fields;
    private final double cellSize;
    private final Map<CellKey, List<Integer>> buckets = new HashMap<>();
    private final List<SamplePoint> pts;

    public GridIndex(List<SamplePoint> pts, List<String> fields, double cellSize) {
        this.pts = pts;
        this.fields = fields;
        this.cellSize = cellSize;
        build();
    }

    private void build() {
        for (int i = 0; i < pts.size(); i++) {
            if (!pts.get(i).valid) continue;
            CellKey key = cellKeyOf(pts.get(i));
            buckets.computeIfAbsent(key, k -> new ArrayList<>()).add(i);
        }
    }

    private CellKey cellKeyOf(SamplePoint p) {
        int d = fields.size();
        long[] c = new long[d];
        for (int k = 0; k < d; k++) {
            double v = p.get(fields.get(k));
            c[k] = (long)Math.floor(v / cellSize);
        }
        return new CellKey(c);
    }

    public List<Integer> candidateIndices(SamplePoint p) {
        CellKey base = cellKeyOf(p);
        List<CellKey> neighbors = base.neighbors(); // 3^d 个邻格
        ArrayList<Integer> out = new ArrayList<>();
        for (CellKey nk : neighbors) {
            List<Integer> ids = buckets.get(nk);
            if (ids != null) out.addAll(ids);
        }
        return out;
    }

    // ---------- CellKey ----------
    public static class CellKey {
        final long[] c;
        final int hash;

        public CellKey(long[] c) {
            this.c = c;
            this.hash = Arrays.hashCode(c);
        }

        @Override public boolean equals(Object o) {
            return (o instanceof CellKey) && Arrays.equals(c, ((CellKey)o).c);
        }
        @Override public int hashCode() { return hash; }

        public List<CellKey> neighbors() {
            List<CellKey> res = new ArrayList<>();
            long[] cur = Arrays.copyOf(c, c.length);
            dfs(res, cur, 0);
            return res;
        }

        private void dfs(List<CellKey> res, long[] cur, int idx) {
            if (idx == cur.length) {
                res.add(new CellKey(Arrays.copyOf(cur, cur.length)));
                return;
            }
            long orig = cur[idx];
            for (long delta = -1; delta <= 1; delta++) {
                cur[idx] = orig + delta;
                dfs(res, cur, idx + 1);
            }
            cur[idx] = orig;
        }
    }
}

---

3.4 用网格哈希加速：半径滤波

把“遍历所有 j”换成“遍历候选邻格里的点”。

java
public class RadiusFilterFast {
    public static int apply(List<SamplePoint> pts, List<String> fields,
                            double radius, int minNeighbors) {

        GridIndex gi = new GridIndex(pts, fields, radius); // cellSize=radius
        int removed = 0;

        for (int i = 0; i < pts.size(); i++) {
            SamplePoint pi = pts.get(i);
            if (!pi.valid) continue;

            int cnt = 0;
            for (int j : gi.candidateIndices(pi)) {
                if (i == j) continue;
                SamplePoint pj = pts.get(j);
                if (!pj.valid) continue;

                double d = MathUtil.euclidean(pi, pj, fields);
                if (d < radius) {
                    cnt++;
                    if (cnt >= minNeighbors) break;
                }
            }
            if (cnt < minNeighbors) {
                pi.valid = false;
                removed++;
            }
        }
        return removed;
    }
}

复杂度直觉：
从 O(n²) 变成约 O(n * k)，其中 k 是“附近候选点数量”。如果数据分布比较均匀，k 通常远小于 n。

---

3.5 用网格哈希加速：最近邻距离滤波

同理，每个点只在候选邻格里找最近邻。

java
public class MinDistanceFilterFast {
    public static int apply(List<SamplePoint> pts, List<String> fields, double threshold) {
        GridIndex gi = new GridIndex(pts, fields, threshold); // cellSize≈threshold 经验上可行

        int removed = 0;
        for (int i = 0; i < pts.size(); i++) {
            SamplePoint pi = pts.get(i);
            if (!pi.valid) continue;

            double best = Double.POSITIVE_INFINITY;
            for (int j : gi.candidateIndices(pi)) {
                if (i == j) continue;
                SamplePoint pj = pts.get(j);
                if (!pj.valid) continue;

                double d = MathUtil.euclidean(pi, pj, fields);
                if (d < best) best = d;
            }

            if (best > threshold) {
                pi.valid = false;
                removed++;
            }
        }
        return removed;
    }
}

注意：最近邻用 cellSize=threshold 只是工程上常用近似设定。更稳的方式：

• cellSize 取一个较小值（例如 threshold/2），
• 或者逐圈扩展邻格直到找到候选点（实现略复杂，但更稳）。

---

四、方案 B（更“正统”）：KD-Tree / BallTree（加分但更难）

4.1 适用场景

• 维度 2~10 仍可用（维度太高也会退化）
• 数据分布很不均匀时，KD-Tree 比网格更稳

4.2 实现建议（毕设可写“用现成库/自己实现简化版”）

你可以：

• 自己实现 2D/3D KD-Tree（不多）
• 或用成熟库（要在论文里说明依赖与原理）

KD-Tree 支持：

• nearest neighbor query：O(log n) 平均
• radius query：O(log n + m)（m 为返回点数）

如果你想走 KD-Tree，我建议你把 fields 固定为 2D/3D，代码量还能控制住；要不然写通用维度 KD-Tree 容易翻车。

---

五、并行化与批处理（让系统更像“工程产品”）

5.1 并行化（CPU 加速）

半径滤波/最近邻滤波每个点的计算相对独立，适合并行：

• 把 i 分块：每块一个线程
• 注意：不要边算边修改 valid（数据竞争）
  • 做法：先算出 toInvalidate[i]=true/false，最后统一应用

伪代码：

java
boolean[] drop = new boolean[n];

IntStream.range(0, n).parallel().forEach(i -> {
    // 只读 pts，计算 drop[i]
});

// 最后单线程更新 valid
for (int i=0; i<n; i++) if (drop[i]) pts.get(i).valid=false;

5.2 批量写入（IO/数据库加速）

如果你把样本写 MySQL：

• 每 1000~5000 条 batch insert/update
• 或者把结果落盘成文件（CSV/Parquet），DB 只存元数据和路径（更快）

---

六、选型建议（你可以直接写进论文的“性能优化方案”）

1. 数据量 <= 2 万：O(n²) 朴素实现即可（简单、好讲）
2. 数据量 2 万 ~ 20 万：先下采样 + 网格哈希（最佳性价比）
3. 数据量 > 20 万 且维度 2~3：网格哈希 + 并行化
4. 数据分布极不均匀 / 维度更高：KD-Tree（或只选 2~3 个关键字段做邻域计算）

---

如果你把参与距离计算的字段告诉我（2D/3D？）以及单批次数据量级（1万/10万/100万），我可以进一步把：

• 标准化怎么做（均值方差在哪算、怎么存）
• radius/threshold 怎么取（给你可操作的经验范围）
• 网格的 cellSize 怎么设更稳（以及“逐圈扩展邻格”的稳健版实现） 一起给你定成最终方案。

下面这四个名字基本就是点云/雷达点集里常见的处理链：SOR（Statistical Outlier Removal）统计离群滤波、ROR（Radius Outlier Removal）半径离群滤波、MD（Minimum Distance）最小距离滤波、VG（Voxel Grid）体素下采样。我按“定义→参数→Java实现要点→复杂度/加速”把你能直接写进代码/论文的版本给出来。

---

0）统一约定：点、距离、字段

你把每个样本点当成 d 维向量（通常 2~3 维最合适）：

• fields 例子：[range, azimuth, velocity] 或 [x, y, z]
• 距离：欧氏距离

java
static double dist(SamplePoint a, SamplePoint b, List<String> fields) {
    double s = 0;
    for (String f : fields) {
        double d = a.get(f) - b.get(f);
        s += d * d;
    }
    return Math.sqrt(s);
}

强烈建议：对 fields 做 z-score 标准化后再做 SOR/ROR/MD（参数更好设、解释更清楚）。

---

1）SOR：统计滤波（Statistical Outlier Removal）

1.1 定义（论文可直接写）

对每个点 $p_i$，找到其 k 个近邻，计算平均距离：

$$\bar{d_i}=\frac{1}{k}\sum_{j=1}^{k} d(p_i, NN_j)$$

对所有点的 $\bar{d_i}$ 计算全局均值 $\mu$ 和标准差 $\sigma$，若：

$$\bar{d_i} > \mu + \alpha\sigma$$

则认为 $p_i$ 是离群点，剔除（置 invalid）。

1.2 参数建议

• k：10~50（常用 20）
• alpha：0.5~2.0（常用 1.0）

1.3 Java（朴素版，数据量小可直接用）

java
static int sor(List<SamplePoint> pts, List<String> fields, int k, double alpha) {
    int n = pts.size();
    double[] meanK = new double[n];

    for (int i = 0; i < n; i++) {
        if (!pts.get(i).valid) { meanK[i] = Double.NaN; continue; }

        // 维护k个最小距离：简单做法用数组收集再部分排序
        double[] best = new double[k];
        java.util.Arrays.fill(best, Double.POSITIVE_INFINITY);

        for (int j = 0; j < n; j++) {
            if (i == j || !pts.get(j).valid) continue;
            double d = dist(pts.get(i), pts.get(j), fields);

            // 插入到best里（k很小，O(k)插入就行）
            for (int t = 0; t < k; t++) {
                if (d < best[t]) {
                    for (int u = k - 1; u > t; u--) best[u] = best[u - 1];
                    best[t] = d;
                    break;
                }
            }
        }

        double sum = 0;
        int cnt = 0;
        for (double v : best) if (Double.isFinite(v)) { sum += v; cnt++; }
        meanK[i] = (cnt == 0) ? Double.POSITIVE_INFINITY : (sum / cnt);
    }

    // 全局mu、sigma
    double mu = 0; int m = 0;
    for (double v : meanK) if (Double.isFinite(v)) { mu += v; m++; }
    mu /= Math.max(1, m);

    double var = 0;
    for (double v : meanK) if (Double.isFinite(v)) var += (v - mu) * (v - mu);
    double sigma = Math.sqrt(var / Math.max(1, m));

    double thr = mu + alpha * sigma;

    int removed = 0;
    for (int i = 0; i < n; i++) {
        if (pts.get(i).valid && meanK[i] > thr) { pts.get(i).valid = false; removed++; }
    }
    return removed;
}

1.4 加速要点

SOR 的瓶颈是 kNN 查询：朴素 O(n²)。想快：

• 2D/3D：用 网格哈希 或 KD-Tree 做近邻候选
• 工程上最简单：先 VG 下采样再做 SOR（效果通常更稳、速度更快）

---

2）ROR：半径滤波（Radius Outlier Removal）

2.1 定义

给定半径 $r$，若点 $p_i$ 的半径邻域内（距离 < r）的邻居数小于阈值 $k$：

$$|\{p_j: d(p_i,p_j) < r\}| < k$$

则认为 $p_i$ 为离群点，剔除。

2.2 参数建议

• radius r：标准化后常用 0.5~2.0；未标准化需按量纲调
• minNeighbors k：3~10

2.3 Java（网格哈希加速版，毕设最推荐）

这比 KD-Tree 好写很多，而且在 2~3 维很快。

思路：cellSize=r，把点放入格子，只检查周围 3^d 个格子候选。

java
static int rorWithGrid(List<SamplePoint> pts, List<String> fields, double r, int minNeighbors) {
    // 1) 建桶
    Map<String, java.util.ArrayList<Integer>> bucket = new java.util.HashMap<>();
    int d = fields.size();

    java.util.function.Function<SamplePoint, long[]> cell = p -> {
        long[] c = new long[d];
        for (int i = 0; i < d; i++) c[i] = (long) Math.floor(p.get(fields.get(i)) / r);
        return c;
    };
    java.util.function.Function<long[], String> key = c -> java.util.Arrays.toString(c);

    for (int i = 0; i < pts.size(); i++) {
        if (!pts.get(i).valid) continue;
        bucket.computeIfAbsent(key.apply(cell.apply(pts.get(i))), k -> new java.util.ArrayList<>()).add(i);
    }

    // 2) 逐点统计邻居
    boolean[] drop = new boolean[pts.size()];
    for (int i = 0; i < pts.size(); i++) {
        SamplePoint pi = pts.get(i);
        if (!pi.valid) continue;

        long[] base = cell.apply(pi);
        int cnt = 0;

        // 枚举邻格：3^d
        int[] delta = new int[d];
        java.util.Arrays.fill(delta, -1);

        while (true) {
            long[] nb = base.clone();
            for (int t = 0; t < d; t++) nb[t] += delta[t];
            var list = bucket.get(key.apply(nb));
            if (list != null) {
                for (int j : list) {
                    if (i == j) continue;
                    if (!pts.get(j).valid) continue;
                    if (dist(pi, pts.get(j), fields) < r) {
                        cnt++;
                        if (cnt >= minNeighbors) break;
                    }
                }
            }
            if (cnt >= minNeighbors) break;

            // delta++（三进制进位：-1,0,1）
            int pos = d - 1;
            while (pos >= 0) {
                if (delta[pos] < 1) { delta[pos]++; break; }
                delta[pos] = -1; pos--;
            }
            if (pos < 0) break;
        }

        if (cnt < minNeighbors) drop[i] = true;
    }

    int removed = 0;
    for (int i = 0; i < pts.size(); i++) if (pts.get(i).valid && drop[i]) { pts.get(i).valid = false; removed++; }
    return removed;
}

---

3）MD：最小距离滤波（Minimum Distance / Nearest-Neighbor Distance）

3.1 定义

对每个点 $p_i$，计算最近邻距离：

$$d_i = \min_{j\neq i} d(p_i,p_j)$$

若 $d_i > T$ 则认为为离群点剔除。

3.2 参数建议

• threshold T：标准化后常用 1.0~3.0（具体看数据疏密）
• 更稳的做法：不用固定 T，改成剔除 d_i 最大的 topX%（论文里也好解释）

3.3 实现（用网格哈希候选 + 最近邻）

• cellSize 可取 T（或 T/2 更稳）
• 候选点只在邻格里搜

实现方式跟 ROR 很像：对每点在候选集合里找最小距离，若没找到候选或最小距离过大则剔除。

如果你要我把 MD 的“逐圈扩展邻格直到找到近邻（更稳）”版补全，我也能给你，但核心逻辑就是：先查 3^d 邻格，没有候选就扩大到 5^d、7^d… 直到找到。

---

4）VG：下采样（Voxel Grid）

4.1 定义（最经典）

用体素边长 leafSize 划分空间，所有落在同一体素的点用一个代表点替代（常见取质心）：

• 体素坐标：$v_k = \lfloor x_k / leaf \rfloor$
• 同体素点集求均值作为新点

4.2 参数建议

• leafSize：决定输出点数与保真度
• 标准化后 leafSize 常用 0.2~1.0（看你想压缩多少）

4.3 Java 实现（HashMap 聚合质心）

java
static List<SamplePoint> voxelGrid(List<SamplePoint> pts, List<String> fields, double leaf) {
    int d = fields.size();

    class Acc {
        double[] sum = new double[d];
        int cnt = 0;
        long tsSum = 0;
        void add(SamplePoint p) {
            for (int i = 0; i < d; i++) sum[i] += p.get(fields.get(i));
            tsSum += p.ts;
            cnt++;
        }
        SamplePoint toPoint() {
            java.util.Map<String, Double> f = new java.util.HashMap<>();
            for (int i = 0; i < d; i++) f.put(fields.get(i), sum[i] / cnt);
            return new SamplePoint(tsSum / Math.max(1, cnt), f);
        }
    }

    Map<String, Acc> map = new HashMap<>();
    for (SamplePoint p : pts) {
        if (!p.valid) continue;
        long[] v = new long[d];
        for (int i = 0; i < d; i++) v[i] = (long)Math.floor(p.get(fields.get(i)) / leaf);
        String key = java.util.Arrays.toString(v);
        map.computeIfAbsent(key, k -> new Acc()).add(p);
    }

    List<SamplePoint> out = new ArrayList<>(map.size());
    for (Acc a : map.values()) out.add(a.toPoint());
    return out;
}

---

5）推荐的处理顺序（你系统里最常用、也最稳）

工程上一般这样串：

1. VG（先降量、稳参数）
2. SOR（去全局统计离群）
3. ROR 或 MD（再清理孤立点/稀疏噪点）
4. 可视化前再做一次轻量下采样（比如每 N 取 1）

---

6）你写论文/答辩时“性能优化”怎么说（简洁好用）

• 朴素实现：SOR/ROR/MD 都需要大量距离计算，复杂度约 O(n²)
• 优化方法：
  • VG 先降采样降低 n
  • 2D/3D 用网格哈希建立空间索引，将候选比较集从 n 降为邻格内的少量点，复杂度近似 O(n·k)

---

如果你把 fields 具体是哪几个（例如 [range, azimuth, velocity] 还是 [x,y,z]）和 单批次点数规模（1万/10万/100万）告诉我，我可以直接给你一套“参数默认值 + 标准化代码 + 网格哈希的稳健版（逐圈扩展）MD/SOR kNN 查询实现”，基本就是可直接抄进项目的最终版本。

下面给你一个**“前端手动修正样本数据”**的可落地方案（Vue + ElementPlus + ECharts），包含：交互设计、前后端数据结构、接口、并发控制、以及关键实现细节。按这个做，答辩时也很好讲“人工复核/可追溯/版本化”。

---

1）你要的“手动修正”到底包含哪些能力

建议把手动修正拆成 3 类（从易到难）：

1. 标记有效/无效（最常用）
   • 选中点/框选点/时间区间 → 置 valid=false/true
2. 字段数值修正（改 range/velocity 等）
   • 单点编辑（表格里直接改）
   • 批量编辑（对选中点做“加偏移/乘系数/设为固定值”）
3. 插入/删除样本（可选，工作量大）
   • 通常毕业设计不强求，做“无效化”就够替代删除

我下面的方案以 1+2 为主（毕业设计性价比最高）。

---

2）总体方案：修正不是直接改原始数据，而是“修正层 + 新版本”

强烈建议：原始版本只读，手动修正产生一个 修正版 Version（或 overlay patch），这样你能讲清楚可追溯。

两种落地方式（二选一）

A. 直接生成新版本（简单直观）

• 用户在前端改 → 提交 → 后端复制父版本数据（或基于父版本生成差分）→ 得到 v1_manual

B. 修正补丁 overlay（更工程、更省空间）

• 原始数据不动
• 单独存“修正记录”（patch），读取时把 patch 合并显示
• 适合数据量大（推荐，但实现稍复杂一点）

毕业设计我建议：B（patch），因为：

• 不需要复制大量数据
• 历史修改可审计、可回滚
• 更像真实系统

---

3）数据模型设计（patch 方案）

3.1 样本唯一定位：sampleId 或（ts + seq）

最好解析入库时给每条样本一个 sample_id（自增/雪花都行）。

3.2 Patch 表（关键）

sample_patch

• id
• version_id（对哪个版本做修正）
• sample_id
• op_type：SET_VALID / UPDATE_FIELDS
• patch_json：例如 { "valid": false } 或 { "range": 123.4, "velocity": 5.6 }
• created_by, created_at

批量修正就是插多条 patch，或者 patch_json 支持批处理（建议多条更清晰、可审计）。

---

4）前端交互怎么做（建议 UI 结构）

页面分 3 区：

4.1 图表区（ECharts scatter/line）

• 展示散点：x=range, y=velocity（或你常用组合）
• valid=false 的点用另一条 series 显示（灰/空心）
• 支持：
  • **框选（brush）**选点
  • **点选（click）**选单点
  • **缩放（dataZoom）**便于精确框选

4.2 表格区（ElementPlus Table）

• 列：sample_id、ts、range、velocity、valid…
• 支持：
  • 行选中与图表联动
  • 单元格 inline 编辑（只允许编辑特定字段）
  • “应用到选中行”的批量操作

4.3 操作面板（右侧 Drawer/Panel）

• 操作类型：
  • 置为有效 / 置为无效
  • 批量数值修正：
    • 加偏移：field += delta
    • 乘系数：field *= k
    • 设为固定值：field = value
• 预览：显示将要影响的点数、字段、参数
• 提交按钮：生成 patch

---

5）ECharts 框选选点怎么做（核心细节）

5.1 用 brush 选点

ECharts 支持 brush 选中散点，拿到选中的 dataIndex，然后映射回 sampleId。

关键：你的每个点数据结构要带 sampleId：

js
// 每个点传给 echarts： [x, y, sampleId]
data: points.map(p => [p.range, p.velocity, p.sampleId])

brush 事件里获取选中点：

js
chart.on('brushSelected', (params) => {
  const selected = [];
  params.batch[0].selected.forEach(sel => {
    sel.dataIndex.forEach(idx => {
      const item = option.series[sel.seriesIndex].data[idx];
      selected.push(item[2]); // sampleId
    });
  });
  selectedSampleIds.value = Array.from(new Set(selected));
});

5.2 图表与表格联动

• 选中表格行 → 高亮对应点（用 markPoint 或另一个 series）
• 选中图表点 → 表格滚动到该行（ElementPlus 的 setCurrentRow）

---

6）前后端接口设计（够用、清晰）

6.1 获取样本（带 patch 合并后的视图）

GET /api/version/{vid}/samples?fields=ts,range,velocity,valid&limit=5000&offset=0

后端做法：

• 查 sample 基础数据
• 查这些 sampleId 对应的 patch
• 合并输出给前端（前端看到的是“当前修正视图”）

6.2 提交修正（批量）

POST /api/version/{vid}/patch 请求体：

json
{
  "op": "SET_VALID",
  "sampleIds": [1,2,3],
  "payload": { "valid": false }
}

或者字段修正：

json
{
  "op": "UPDATE_FIELDS",
  "sampleIds": [1,2,3],
  "payload": { "range": 123.4, "velocity": 5.6 }
}

6.3 批量“运算型修正”（推荐单独接口，后端算更安全）

POST /api/version/{vid}/patch/transform

json
{
  "sampleIds": [1,2,3],
  "transform": [
    { "field": "range", "op": "ADD", "value": 1.5 },
    { "field": "velocity", "op": "MUL", "value": 0.98 }
  ]
}

这样前端不用自己算，避免浮点误差和被篡改参数；后端也能记录审计。

6.4 撤销/回滚（加分）

DELETE /api/version/{vid}/patch?patchIds=...
或者 POST /api/version/{vid}/patch/undoLast

---

7）并发与安全：避免“别人改了你不知道”

至少做一个轻量的乐观锁：

• version 表有 patch_revision（每次 patch +1）
• 前端提交 patch 时带上 ifRevision
• 后端校验不一致就返回 409，前端提示“数据已更新，请刷新后重试”

请求示例：

json
{
  "op":"SET_VALID",
  "sampleIds":[1,2,3],
  "payload":{"valid":false},
  "ifRevision": 12
}

---

8）性能：为什么前端不能一次加载所有点

雷达/点云数据很容易几十万点，前端渲染会卡。

建议：

• 默认只取 limit=5000~20000 点用于可视化（可叠加 VG 下采样）
• 表格分页（后端分页）
• 修正时只提交 sampleId 列表（很小）

如果你要支持“时间区间修正”，就别传所有 sampleId：

• 前端传条件（tsFrom/tsTo + filters）
• 后端查出匹配 sampleId 并生成 patch（更稳）

---

9）你可以直接做的最小实现（MVP）

1. 图表 scatter + brush 框选得到 sampleIds
2. 操作按钮：置无效 / 置有效
3. PATCH 接口写入 sample_patch
4. 刷新图表与表格（后端合并 patch 输出）

完成这四步，你的“手动修正”就已经像一个真实系统了。

---

如果你告诉我你可视化主要用哪两个字段做散点（比如 range-velocity 还是 x-y），以及你的样本是不是有 sampleId（或者只能靠 ts+序号 定位），我可以把：

• ECharts option（含 brush、联动、高亮）
• ElementPlus 表格 inline 编辑
• 提交 patch 的 Vue 组件代码结构
  直接给你一份更贴近你数据的模板。