数据层大重构：文件→分组 / 时间轴一等公民 / 加载器抽象 + CSV 多时间轴 + MF4 支持
一、数据模型解耦（详见 Documents/refactor_report_2026-10-15.md 与 agent_mem §9.27）
1. DataFile → SignalGroup：删除 filePath / fileName / time / timeColumnName / timeMonotonic /
minTime / maxTime —— 「分组」是应用内的逻辑容器，加载完成后与磁盘文件再无关系。
2. 新增 TimeAxis（name / time / minTime / maxTime / monotonic / finiteCount），一个分组可含 1..N 条；
SignalData 新增 axisIndex 指向所属时间轴，采样值与时间的对应关系自包含。
3. SignalData 删除冗余的 rawHeader（name 的副本）与 unit（由列名猜出、全仓无人使用）；
名字只保留 name（源名称）+ displayName（用户重命名），Title() 统一展示。
4. SignalRef::fileIndex → groupIndex；DataSet：AddGroup/RemoveGroup/GroupAt/GroupCount/Groups()/
SetGroupDisplayName/RemapSelectionAfterGroupRemoval + 新增 Axis(ref)；
TabConfig：SetGroupVisible/GroupHasVisible/GroupAllVisible/RemapAfterGroupRemoval +
RowKind::GROUP / CMD_GROUP_*。
5. 采样与统计 API 首参由 const DataFile& 改为 const TimeAxis&：
SampleSignalAt / SampleDisplayedSignalAt / FindNearestSample（Utilities）与
SampleSpacingPixels / VisibleIndexRange / EdgeIndexRange / MeanFilterValueAt / WeakPeakValueAt /
EdgeCountsFor / EdgeCenterCountsFor / EdgeScanFor（PlotView）。
6. 视图层：ResolvedSignal = { data, style, group, axis, visible }；PolylineCacheEntry::file→group；
EdgeScanState::file→axis（统计身份 = 时间轴 + 信号）；
ComputeVisibleTimeBounds 只统计可见信号真正用到的时间轴。
二、加载层抽象（格式与模型彻底解耦）
- 新增 Utilities/Inc/DataTable.hpp：DataTable（通用列优先表格）+ LoadProgress/Info +
TableBlock（一个时间轴块）+ LoadedSource（源文件全部块）。
- 新增 Utilities/Inc|Src/DataLoader.*：唯一入口 LoadSignalSource 按扩展名分发 +
IsSupportedSignalFile + SignalFileDialogFilter。
- 新增 Utilities/Inc|Src/CsvLoader.*：CSV 解析 + 多时间轴切分 + 各轴按自己的时间列裁剪。
- 新增 Utilities/Inc|Src/Mf4Loader.*：ASAM MDF v4 解析。
- 删除 Utilities/Inc/CsvTable.hpp 与 Utilities/Src/CsvTable.cpp。
- 唯一装配点 BuildSignalGroup(LoadedSource&&, paletteBase, group, error, progress)：
时间轴去重合并 + 信号命名 + 调色板取色 + 统计与粗粒度包络；新增格式只需写一个加载器。
三、CSV 多时间轴（修正用户报告的缺陷）
- 只有名为 t/time/timestamp/simulation time/时间/时间轴 的列是时间轴（判据收紧，
不再用「包含 time」以免把 timeout 误判成时间轴）。
- 每个时间列开启一个新块，其后直到下一个时间列之前的列都属于该块；各块按自己的时间列裁剪
⇒ 支持各轴长度不同（Multi_Timeline.CSV 实测切出 3 条轴，长度 7/4/7）；
**不再把其它 time 列当成信号显示**。
- 完全没有时间列时保留旧行为（第一列当时间轴，单轴）。
四、MF4 支持（新功能）
- 加载后新建一个分组、组名 = 文件名，文件内全部信号归入该分组。
- 每个通道组（CG）是一条时间轴，内容相同的时间轴自动合并（实测 27 个 CG → 3 条轴 / 124 条信号）。
- 实现 MDF v4 块解析（HD/DG/CG/CN/CC/DT）、1–64 位整数（任意位偏移、含符号扩展）与
32/64 位 IEEE 浮点解码、无效位（inval bit）处理、线性换算 phys = cc_val[0] + cc_val[1]*raw。
- TX 文本块同时兼容规范写法（U32 长度 + UTF-16/UTF-8）与 CANape 的「无长度前缀 NUL 结尾裸文本」。
- 未实现（跳过该组）：压缩块 ##DZ/##HL/##SD、##DL 数据列表、字符串/MIME 通道。
五、顺带修复
- Application::Initialize：窗口类已注册（ERROR_CLASS_ALREADY_EXISTS）时复用而不是弹模态错误框
（旧实现让同一进程第二次构造 Application 永久阻塞）；Shutdown 注销窗口类并销毁窗口。
- UI 文案统一到「分组」：选中该分组全部信号 / 取消该分组全部信号 / 关闭该分组（从工作区移除）/
请关闭部分分组或信号后重试。/ 尚未加载数据，请打开数据文件 / 打开数据文件以查看波形 /
（可同时加载多个文件，各自成为一个分组）；对话框过滤器增加 *.mf4/*.mdf。
六、验证（全部离屏：BELOW_NORMAL 优先级 + SW_HIDE 窗口 + 只注入合成消息）
- 新增 .preflight/perf/datacheck_main.cpp：69/69 通过（单轴 CSV 回归、多时间轴 CSV、MF4 组名/信号数/
时间轴/主时间轴 ns→s/setSpeed 首样本与原始字节人工核对、DataSet 不变量、派生信号沿用源轴、
MF4 集成 124 信号并一格 60~68ms/帧）。
- 新增 .preflight/perf/edgecheck_main.cpp（ASCII-only，替代被编码破坏的 panelcheck）：46/46 通过
（「调整」符号规则走真实菜单路径、边沿统计按帧推进/不饿死/逐位一致/无鼠标输入也完成、
面板两列等宽与信号名限宽、弱峰复位控件）。
- 既有 .preflight/perf/verify_main.cpp（已适配新 API）：47/47，另有 2 条本机未同步的旧规则断言
（derived offsetTime kept / mouse in lane1 lower half），与本轮无关。
- make clean && make all 零警告。
This commit is contained in:
DeepSeek V4.1 Flash committed
1 parent
fba40ee1a2
commit
6eedbe3c5d
18 files changed
+2545
-817
No files matched your search
@@ -0,0 +1,33 @@
|
||||
#ifndef __CSV_LOADER_HPP__
|
||||
#define __CSV_LOADER_HPP__
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "DataTable.hpp"
|
||||
|
||||
namespace jdi
|
||||
{
|
||||
|
||||
/**
|
||||
* @brief 读取并解析一个 CSV 文本文件。
|
||||
*
|
||||
* 文件以分块流式方式读取（不把整个文件一次性读入内存），
|
||||
* 因此内存占用只与解析结果相关，不会因文件体积成倍放大，也没有体积上限。
|
||||
*
|
||||
* **多时间轴**：CSV 允许出现多个时间列（列名形如 `time`）。每个时间列都会开启一个新的
|
||||
* 时间轴块，它**之后**直到下一个时间列之前的所有列都属于该块。
|
||||
* 各块之间的行数可以不一致（较短的时间轴在数据区提前结束，其余位置留空）。
|
||||
* 只出现一个时间列时结果与旧的单时间轴行为完全一致。
|
||||
*
|
||||
* @param [IN] filePath CSV 文件完整路径（宽字符，支持中文路径）。
|
||||
* @param [OUT] source 解析结果（按时间列切分为若干时间轴块）。
|
||||
* @param [OUT] error 失败原因描述（成功时清空）。
|
||||
* @param [IN] progress 解析进度回调，可为空。
|
||||
* @return 解析成功返回 true，否则返回 false。
|
||||
*/
|
||||
bool LoadCsvSource(const std::wstring& filePath, LoadedSource& source, std::wstring& error,
|
||||
const LoadProgress& progress = LoadProgress());
|
||||
|
||||
} // namespace jdi
|
||||
|
||||
#endif // __CSV_LOADER_HPP__
|
||||
@@ -1,76 +0,0 @@
|
||||
#ifndef __CSV_TABLE_HPP__
|
||||
#define __CSV_TABLE_HPP__
|
||||
|
||||
#include <cstddef>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace jdi
|
||||
{
|
||||
|
||||
/**
|
||||
* @brief CSV 文件的解析结果，保存列名与**列优先**的数值矩阵。
|
||||
*
|
||||
* 采用列优先（每条信号一整块连续内存）而不是行优先的二维数组，原因有二：
|
||||
* 1. 大型文件（百万行级）若按行存储会产生上百万次独立堆分配，
|
||||
* 每行还要额外承担 vector 的控制块与容量对齐开销，实测内存放大接近 1.5 倍；
|
||||
* 2. 后续构建信号时可以直接把整列**移动**进 SignalData，不再逐元素拷贝。
|
||||
*/
|
||||
struct CsvTable
|
||||
{
|
||||
std::vector<std::wstring> headers; /**< 列名（已去除引号与首尾空白）。 */
|
||||
std::vector<std::vector<double>> columns; /**< 列优先数值矩阵：columns[列][行]，缺失处为 NaN。 */
|
||||
std::size_t rowCount = 0; /**< 有效数据行数。 */
|
||||
wchar_t delimiter = L','; /**< 实际使用的分隔符。 */
|
||||
unsigned long long fileBytes = 0; /**< 源文件字节数（用于按比例预留容量）。 */
|
||||
|
||||
/**
|
||||
* @brief 判断解析结果是否包含可用的表格数据。
|
||||
* @return 存在列名且存在数据行时返回 true。
|
||||
*/
|
||||
bool HasData() const
|
||||
{
|
||||
return !headers.empty() && (rowCount > 0);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 加载进度信息。
|
||||
*
|
||||
* 解析阶段会携带真实的"已读 / 总字节数"；列重组与统计阶段没有字节可计，
|
||||
* 此时 `hasBytes` 为 false，界面应只展示百分比。
|
||||
*/
|
||||
struct CsvProgressInfo
|
||||
{
|
||||
double ratio = 0.0; /**< 0-1 总体完成比例。 */
|
||||
unsigned long long bytesRead = 0; /**< 已读取字节数。 */
|
||||
unsigned long long totalBytes = 0; /**< 文件总字节数。 */
|
||||
bool hasBytes = false; /**< 上述字节数字段是否有效。 */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 解析进度回调。
|
||||
*
|
||||
* 在解析过程中按块回调；返回 false 表示请求取消，解析会尽快停止并返回失败。
|
||||
*/
|
||||
using CsvProgress = std::function<bool(const CsvProgressInfo& info)>;
|
||||
|
||||
/**
|
||||
* @brief 读取并解析一个 CSV 文件。
|
||||
*
|
||||
* 文件以分块流式方式读取（不把整个文件一次性读入内存），
|
||||
* 因此内存占用只与解析结果相关，不会因文件体积成倍放大，也没有体积上限。
|
||||
*
|
||||
* @param [IN] filePath CSV 文件完整路径（宽字符，支持中文路径）。
|
||||
* @param [OUT] table 解析结果输出。
|
||||
* @param [OUT] error 失败原因描述（成功时清空）。
|
||||
* @param [IN] progress 解析进度回调，可为空。
|
||||
* @return 解析成功返回 true，否则返回 false。
|
||||
*/
|
||||
bool LoadCsvTable(const std::wstring& filePath, CsvTable& table, std::wstring& error,
|
||||
const CsvProgress& progress = CsvProgress());
|
||||
|
||||
} // namespace jdi
|
||||
|
||||
#endif // __CSV_TABLE_HPP__
|
||||
@@ -0,0 +1,45 @@
|
||||
#ifndef __DATA_LOADER_HPP__
|
||||
#define __DATA_LOADER_HPP__
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "DataTable.hpp"
|
||||
|
||||
namespace jdi
|
||||
{
|
||||
|
||||
/**
|
||||
* @brief 判断路径是否为应用当前支持的测量文件（按扩展名判断，不访问文件内容）。
|
||||
* @param [IN] filePath 文件路径。
|
||||
* @return 支持返回 true。
|
||||
*/
|
||||
bool IsSupportedSignalFile(const std::wstring& filePath);
|
||||
|
||||
/**
|
||||
* @brief 供「打开文件」对话框使用的过滤器文本（`GetOpenFileNameW` 的 `lpstrFilter` 格式）。
|
||||
* @return 双 NUL 结尾的过滤器文本。
|
||||
*/
|
||||
const wchar_t* SignalFileDialogFilter();
|
||||
|
||||
/**
|
||||
* @brief 按扩展名选择加载器并读入一个测量文件（**唯一的文件加载入口**）。
|
||||
*
|
||||
* 上层（数据模型与界面）只依赖本函数返回的 `LoadedSource`，因此新增格式时
|
||||
* **只需新增一个加载器并在这里登记**，其余代码完全不用改。
|
||||
*
|
||||
* 当前支持的格式：
|
||||
* * CSV 文本（`.csv` / `.txt`）：支持多个 `time` 列（多时间轴）与各时间轴不等长；
|
||||
* * ASAM MDF v4（`.mf4` / `.mdf`）：每个通道组（CG）是一个时间轴。
|
||||
*
|
||||
* @param [IN] filePath 文件完整路径。
|
||||
* @param [OUT] source 解析结果（若干时间轴块）。
|
||||
* @param [OUT] error 失败原因描述（成功时清空）。
|
||||
* @param [IN] progress 进度回调，可为空。
|
||||
* @return 加载成功返回 true。
|
||||
*/
|
||||
bool LoadSignalSource(const std::wstring& filePath, LoadedSource& source, std::wstring& error,
|
||||
const LoadProgress& progress = LoadProgress());
|
||||
|
||||
} // namespace jdi
|
||||
|
||||
#endif // __DATA_LOADER_HPP__
|
||||
+210
-105
@@ -9,7 +9,8 @@
|
||||
#include <atomic>
|
||||
#include <vector>
|
||||
|
||||
#include "CsvTable.hpp"
|
||||
#include "DataLoader.hpp"
|
||||
#include "DataTable.hpp"
|
||||
|
||||
namespace jdi
|
||||
{
|
||||
@@ -61,18 +62,23 @@ namespace jdi
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 全局信号引用：文件下标 + 文件内信号下标。
|
||||
* @brief 全局信号引用：**分组下标 + 组内信号下标**。
|
||||
*
|
||||
* ⚠️ 这里的「分组」是信号在应用内的**逻辑归属**（加载一个文件形成一个分组，
|
||||
* 用户可以重命名），与磁盘上的文件**没有任何关系**：文件可以在加载后被移动、
|
||||
* 重命名甚至删除，已加载的数据不受影响。因此引用只由两个下标构成，
|
||||
* 不携带路径等易失效的信息。
|
||||
*/
|
||||
struct SignalRef
|
||||
{
|
||||
int fileIndex = -1; /**< 所属文件下标。 */
|
||||
int signalIndex = -1; /**< 文件内信号下标。 */
|
||||
int groupIndex = -1; /**< 所属分组下标。 */
|
||||
int signalIndex = -1; /**< 组内信号下标。 */
|
||||
|
||||
/**
|
||||
* @brief 判断引用是否指向有效位置。
|
||||
* @return 两个下标均非负返回 true。
|
||||
*/
|
||||
bool IsValid() const { return fileIndex >= 0 && signalIndex >= 0; }
|
||||
bool IsValid() const { return groupIndex >= 0 && signalIndex >= 0; }
|
||||
|
||||
/**
|
||||
* @brief 相等比较。
|
||||
@@ -81,7 +87,7 @@ namespace jdi
|
||||
*/
|
||||
bool operator==(const SignalRef& other) const
|
||||
{
|
||||
return fileIndex == other.fileIndex && signalIndex == other.signalIndex;
|
||||
return groupIndex == other.groupIndex && signalIndex == other.signalIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -261,15 +267,42 @@ namespace jdi
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 一条时间轴（时间向量 + 它的取值范围与单调性）。
|
||||
*
|
||||
* 时间轴**独立于信号**：同一分组内多条信号可以共用同一条时间轴（最常见的 CSV 单时间轴文件、
|
||||
* MF4 里同一通道组内的全部通道），也可以各自使用不同的时间轴（多 `time` 列的 CSV、
|
||||
* MF4 的不同通道组）。
|
||||
*/
|
||||
struct TimeAxis
|
||||
{
|
||||
std::wstring name; /**< 时间列名（源文件中的原样名称，如 `time`）。 */
|
||||
std::vector<double> time; /**< 时间数值，缺失处为 NaN。 */
|
||||
double minTime = 0.0; /**< 有限时间最小值。 */
|
||||
double maxTime = 0.0; /**< 有限时间最大值。 */
|
||||
bool monotonic = true; /**< 时间是否单调不减（决定能否用下标区间做二分）。 */
|
||||
std::size_t finiteCount = 0; /**< 有效时间点数量。 */
|
||||
|
||||
/** @brief 时间点数量。 */
|
||||
std::size_t Count() const { return time.size(); }
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 单条信号的元数据与采样值（纯数据，不含可见性配置）。
|
||||
*
|
||||
* ⚠️ 信号**只有两个名字字段，各有明确职责**，不要再引入第三个：
|
||||
* * `name` —— 源名称（列名 / 通道名），加载后**原样保留、永不修改**；
|
||||
* * `displayName` —— 用户在界面上重命名后的名称，为空表示“用源名称”。
|
||||
* 界面展示一律走 `Title()`。
|
||||
*
|
||||
* ⚠️ 信号的时间轴由 `axisIndex` 指向所属分组的时间轴列表，
|
||||
* 因此采样值本身不需要、也不应该携带时间信息。
|
||||
*/
|
||||
struct SignalData
|
||||
{
|
||||
std::wstring name; /**< 名称（取自文件列名，完全保留原样）。 */
|
||||
std::wstring displayName; /**< 用户重命名的显示名；为空时使用 name。 */
|
||||
std::wstring rawHeader; /**< 原始列名。 */
|
||||
std::wstring unit; /**< 从列名括号中提取的单位，可能为空。 */
|
||||
std::wstring name; /**< 源名称（列名 / 通道名，原样保留）。 */
|
||||
std::wstring displayName; /**< 用户重命名后的显示名；为空时使用 name。 */
|
||||
std::size_t axisIndex = 0; /**< 所属时间轴在分组内的下标。 */
|
||||
std::vector<double> values; /**< 采样值，缺失处为 NaN。 */
|
||||
double minValue = 0.0; /**< 有限采样值最小值。 */
|
||||
double maxValue = 0.0; /**< 有限采样值最大值。 */
|
||||
@@ -292,89 +325,154 @@ namespace jdi
|
||||
|
||||
/**
|
||||
* @brief 获取用于界面展示的名称。
|
||||
* @return 用户重命名后的显示名，未重命名时返回文件中的原始名称。
|
||||
* @return 用户重命名后的显示名，未重命名时返回源名称。
|
||||
*/
|
||||
const std::wstring& Title() const { return displayName.empty() ? name : displayName; }
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 一个已加载的数据文件及其自有时间轴。
|
||||
* @brief 一个**信号分组**：一次加载产生的全部信号，以及它们使用的若干条时间轴。
|
||||
*
|
||||
* ⚠️ 「分组」是应用内的逻辑容器，**不是文件**：加载完成后二者已无关系，
|
||||
* 因此这里**不保存文件路径**（路径只在加载那一刻用于错误提示，之后毫无用处）。
|
||||
* 分组的默认名称取源文件名（便于用户辨认来源），用户可以重命名。
|
||||
*
|
||||
* 一个分组可以包含**多条时间轴**（CSV 的多个 `time` 列、MF4 的多个通道组），
|
||||
* 每条信号通过 `SignalData::axisIndex` 指向自己那条。
|
||||
*/
|
||||
struct DataFile
|
||||
struct SignalGroup
|
||||
{
|
||||
std::wstring filePath; /**< 文件完整路径（仅用于状态提示）。 */
|
||||
std::wstring fileName; /**< 文件名称。 */
|
||||
std::wstring displayName; /**< 用户重命名的分组名；为空时使用 fileName。 */
|
||||
std::wstring timeColumnName; /**< 时间列列名。 */
|
||||
std::vector<double> time; /**< 时间轴数值。 */
|
||||
std::vector<SignalData> signals; /**< 该文件包含的信号。 */
|
||||
double minTime = 0.0; /**< 时间轴最小值。 */
|
||||
double maxTime = 0.0; /**< 时间轴最大值。 */
|
||||
bool timeMonotonic = true; /**< 时间轴是否单调不减。 */
|
||||
std::wstring name; /**< 分组默认名称（源文件名，含扩展名）。 */
|
||||
std::wstring displayName; /**< 用户重命名后的分组名；为空时使用 name。 */
|
||||
std::vector<TimeAxis> axes; /**< 该分组使用的时间轴（至少一条）。 */
|
||||
std::vector<SignalData> signals; /**< 该分组包含的信号。 */
|
||||
|
||||
/**
|
||||
* @brief 获取用于界面展示的分组名。
|
||||
* @return 用户重命名后的显示名，未重命名时返回文件名。
|
||||
* @return 用户重命名后的显示名，未重命名时返回源文件名。
|
||||
*/
|
||||
const std::wstring& Title() const { return displayName.empty() ? fileName : displayName; }
|
||||
const std::wstring& Title() const { return displayName.empty() ? name : displayName; }
|
||||
|
||||
/**
|
||||
* @brief 取某条信号所属的时间轴（下标越界时回退到第一条，保证永不返回悬空引用）。
|
||||
* @param [IN] signal 目标信号。
|
||||
* @return 时间轴引用；分组没有任何时间轴时返回内部静态空时间轴。
|
||||
*/
|
||||
const TimeAxis& AxisOf(const SignalData& signal) const
|
||||
{
|
||||
return AxisAt(signal.axisIndex);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 按下标取时间轴（越界时回退到第一条）。
|
||||
* @param [IN] index 时间轴下标。
|
||||
* @return 时间轴引用。
|
||||
*/
|
||||
const TimeAxis& AxisAt(std::size_t index) const
|
||||
{
|
||||
static const TimeAxis kEmptyAxis;
|
||||
if (axes.empty())
|
||||
{
|
||||
return kEmptyAxis;
|
||||
}
|
||||
return axes[(index < axes.size()) ? index : 0];
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 计算本分组全部时间轴的时间范围并集。
|
||||
* @param [OUT] low 下限。 @param [OUT] high 上限。
|
||||
* @return 至少有一条时间轴有有效时间返回 true。
|
||||
*/
|
||||
bool TimeRange(double& low, double& high) const
|
||||
{
|
||||
low = 0.0;
|
||||
high = 0.0;
|
||||
bool valid = false;
|
||||
for (const TimeAxis& axis : axes)
|
||||
{
|
||||
if (axis.finiteCount == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (!valid)
|
||||
{
|
||||
low = axis.minTime;
|
||||
high = axis.maxTime;
|
||||
valid = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
low = std::min(low, axis.minTime);
|
||||
high = std::max(high, axis.maxTime);
|
||||
}
|
||||
}
|
||||
return valid;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 由 CSV 解析结果构建可入库的数据文件。
|
||||
* @brief 由一个**格式无关**的加载结果构建应用内的信号分组。
|
||||
*
|
||||
* 该函数**不访问 DataSet**（只依赖传入的 CsvTable 与调色板基准序号），
|
||||
* 因此可以在工作线程上执行：大文件的解析与列重组占整个加载耗时的大头，
|
||||
* 放到工作线程后主线程只需做一次 O(1) 的移动入队，加载过程中的界面不会卡住。
|
||||
* 职责划分（新增文件格式时只需要写一个加载器，本函数完全不用改）：
|
||||
* * 加载器：文件 → `LoadedSource`（若干「时间轴块」，纯格子，无应用语义）；
|
||||
* * 本函数：`LoadedSource` → `SignalGroup`（时间轴**去重合并**、信号命名、
|
||||
* 调色板取色、统计与粗粒度包络层）。
|
||||
*
|
||||
* table 按右值传入：每列会被**移动**进对应信号的 values（零拷贝）。
|
||||
* 时间轴去重：内容完全相同（长度与全部数值逐位相同）的时间轴只保留一条，
|
||||
* 于是 CSV 里多个同刻度的 `time` 列、MF4 里多个同基线的通道组不会重复占内存，
|
||||
* 也不会让信号各自持有实质上相同的轴。
|
||||
*
|
||||
* @param [IN,OUT] table CSV 解析结果（列会被移走）。
|
||||
* @param [IN] filePath 源文件路径。
|
||||
* 该函数**不访问 DataSet**（只依赖传入数据与调色板基准序号），因此可以在工作线程上执行：
|
||||
* 大文件的解析与列重组占整个加载耗时的大头，放到工作线程后主线程只需做一次 O(1) 的
|
||||
* 移动入队，加载过程中的界面不会卡住。
|
||||
*
|
||||
* @param [IN,OUT] source 加载结果（列会被**移动**进信号，零拷贝）。
|
||||
* @param [IN] paletteBase 调色板起始序号（通常传入当前已有信号数）。
|
||||
* @param [OUT] file 构建结果。
|
||||
* @param [OUT] group 构建结果。
|
||||
* @param [OUT] error 失败原因描述（成功时清空）。
|
||||
* @param [IN] progress 进度回调（0-1），返回 false 表示取消，可为空。
|
||||
* @return 构建成功返回 true。
|
||||
*/
|
||||
bool BuildDataFile(CsvTable&& table, const std::wstring& filePath, std::size_t paletteBase, DataFile& file,
|
||||
std::wstring& error, const CsvProgress& progress = CsvProgress());
|
||||
bool BuildSignalGroup(LoadedSource&& source, std::size_t paletteBase, SignalGroup& group,
|
||||
std::wstring& error, const LoadProgress& progress = LoadProgress());
|
||||
|
||||
/**
|
||||
* @brief 数据集合：统一管理全部已加载文件，与视图配置无关。
|
||||
* @brief 数据集合：统一管理全部已加载的**信号分组**，与视图配置无关。
|
||||
*/
|
||||
class DataSet
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* @brief 追加一个已构建好的数据文件（仅做一次移动，不拷贝采样数据）。
|
||||
* @param [IN,OUT] file 数据文件（内部缓冲会被移走）。
|
||||
* @param [OUT] fileIndex 新文件下标。
|
||||
* @brief 追加一个已构建好的信号分组（仅做一次移动，不拷贝采样数据）。
|
||||
* @param [IN,OUT] group 信号分组（内部缓冲会被移走）。
|
||||
* @param [OUT] groupIndex 新分组下标。
|
||||
* @return 追加成功返回 true。
|
||||
*/
|
||||
bool AddDataFile(DataFile&& file, int& fileIndex);
|
||||
bool AddGroup(SignalGroup&& group, int& groupIndex);
|
||||
|
||||
/**
|
||||
* @brief 在指定文件的指定信号**下方**插入一条新信号（派生信号）。
|
||||
* @brief 在指定分组的指定信号**下方**插入一条新信号（派生信号）。
|
||||
*
|
||||
* 新信号会占据 `afterSignalIndex + 1` 的位置，该位置及其后的信号下标整体后移一位；
|
||||
* 调用方必须紧接着对每个标签页调用 `TabConfig::RemapAfterSignalInsert()` 修正引用。
|
||||
* 采样值会被就地统计（min/max/finiteCount 与粗粒度包络层），显示外观按「全局信号序号」
|
||||
* 取调色板颜色（与普通新信号一致）。
|
||||
*
|
||||
* @param [IN] fileIndex 目标文件下标。
|
||||
* @param [IN] groupIndex 目标分组下标。
|
||||
* @param [IN] afterSignalIndex 插入位置的上一条信号下标。
|
||||
* @param [IN,OUT] signal 待插入的信号（values 会被统计，其余字段原样使用）。
|
||||
* @param [OUT] newSignalIndex 新信号在本文件内的下标。
|
||||
* @param [OUT] newSignalIndex 新信号在本组内的下标。
|
||||
* @return 插入成功返回 true。
|
||||
*/
|
||||
bool InsertDerivedSignal(int fileIndex, int afterSignalIndex, SignalData&& signal, int& newSignalIndex);
|
||||
bool InsertDerivedSignal(int groupIndex, int afterSignalIndex, SignalData&& signal,
|
||||
int& newSignalIndex);
|
||||
|
||||
/**
|
||||
* @brief 移除指定下标的文件，并立即释放其占用的全部采样内存。
|
||||
* @param [IN] fileIndex 文件下标。
|
||||
* @brief 移除指定下标的分组，并立即释放其占用的全部采样内存。
|
||||
* @param [IN] groupIndex 分组下标。
|
||||
* @return 移除成功返回 true。
|
||||
*/
|
||||
bool RemoveFile(int fileIndex);
|
||||
bool RemoveGroup(int groupIndex);
|
||||
|
||||
/**
|
||||
* @brief 从某个分组中移除一条信号，并立即释放它的采样内存。
|
||||
@@ -383,30 +481,30 @@ namespace jdi
|
||||
* `TabConfig::RemapAfterSignalRemoval()`，并用 `RemapSelectionAfterSignalRemoval()`
|
||||
* 修正共享选中项。使用者一旦确认不再需要该信号即可调用，本调用后其采样缓冲立即析构。
|
||||
*
|
||||
* @param [IN] fileIndex 信号所属文件下标。
|
||||
* @param [IN] signalIndex 文件内信号下标。
|
||||
* @param [IN] groupIndex 信号所属分组下标。
|
||||
* @param [IN] signalIndex 组内信号下标。
|
||||
* @return 移除成功返回 true。
|
||||
*/
|
||||
bool RemoveSignal(int fileIndex, int signalIndex);
|
||||
bool RemoveSignal(int groupIndex, int signalIndex);
|
||||
|
||||
/**
|
||||
* @brief 在数据层移除某条信号之前，按旧下标修正选中引用。
|
||||
* @param [IN] fileIndex 信号所属文件下标。
|
||||
* @param [IN] groupIndex 信号所属分组下标。
|
||||
* @param [IN] signalIndex 即将被移除的信号下标。
|
||||
*/
|
||||
void RemapSelectionAfterSignalRemoval(int fileIndex, int signalIndex);
|
||||
void RemapSelectionAfterSignalRemoval(int groupIndex, int signalIndex);
|
||||
|
||||
/**
|
||||
* @brief 判断数据集合是否为空。
|
||||
* @return 未加载任何文件返回 true。
|
||||
* @return 未加载任何分组返回 true。
|
||||
*/
|
||||
bool Empty() const { return m_files.empty(); }
|
||||
bool Empty() const { return m_groups.empty(); }
|
||||
|
||||
/**
|
||||
* @brief 获取文件数量。
|
||||
* @return 文件数量。
|
||||
* @brief 获取分组数量。
|
||||
* @return 分组数量。
|
||||
*/
|
||||
std::size_t FileCount() const { return m_files.size(); }
|
||||
std::size_t GroupCount() const { return m_groups.size(); }
|
||||
|
||||
/**
|
||||
* @brief 获取信号总数。
|
||||
@@ -415,34 +513,34 @@ namespace jdi
|
||||
std::size_t SignalCount() const;
|
||||
|
||||
/**
|
||||
* @brief 获取全部文件（只读）。
|
||||
* @return 文件集合。
|
||||
* @brief 获取全部分组（只读）。
|
||||
* @return 分组集合。
|
||||
*/
|
||||
const std::vector<DataFile>& Files() const { return m_files; }
|
||||
const std::vector<SignalGroup>& Groups() const { return m_groups; }
|
||||
|
||||
/**
|
||||
* @brief 按下标获取文件。
|
||||
* @param [IN] fileIndex 文件下标。
|
||||
* @return 文件指针，下标非法时返回 nullptr。
|
||||
* @brief 按下标获取分组。
|
||||
* @param [IN] groupIndex 分组下标。
|
||||
* @return 分组指针，下标非法时返回 nullptr。
|
||||
*/
|
||||
const DataFile* FileAt(int fileIndex) const;
|
||||
const SignalGroup* GroupAt(int groupIndex) const;
|
||||
|
||||
/**
|
||||
* @brief 修改某个信号在界面上的显示名称。
|
||||
* @param [IN] fileIndex 文件下标。
|
||||
* @param [IN] signalIndex 文件内信号下标。
|
||||
* @param [IN] name 新的显示名；传入空串表示恢复使用原始列名。
|
||||
* @brief 修改某条信号在界面上的显示名称。
|
||||
* @param [IN] groupIndex 分组下标。
|
||||
* @param [IN] signalIndex 组内信号下标。
|
||||
* @param [IN] name 新的显示名；传入空串表示恢复使用源名称。
|
||||
* @return 修改成功返回 true。
|
||||
*/
|
||||
bool SetSignalDisplayName(int fileIndex, int signalIndex, const std::wstring& name);
|
||||
bool SetSignalDisplayName(int groupIndex, int signalIndex, const std::wstring& name);
|
||||
|
||||
/**
|
||||
* @brief 修改某个文件分组的显示名称。
|
||||
* @param [IN] fileIndex 文件下标。
|
||||
* @param [IN] name 新的分组名；传入空串表示恢复使用文件名。
|
||||
* @brief 修改某个分组的显示名称。
|
||||
* @param [IN] groupIndex 分组下标。
|
||||
* @param [IN] name 新的分组名；传入空串表示恢复使用默认名称。
|
||||
* @return 修改成功返回 true。
|
||||
*/
|
||||
bool SetFileDisplayName(int fileIndex, const std::wstring& name);
|
||||
bool SetGroupDisplayName(int groupIndex, const std::wstring& name);
|
||||
|
||||
/**
|
||||
* @brief 解析信号引用。
|
||||
@@ -451,6 +549,13 @@ namespace jdi
|
||||
*/
|
||||
const SignalData* Resolve(const SignalRef& ref) const;
|
||||
|
||||
/**
|
||||
* @brief 取某条信号所属的时间轴。
|
||||
* @param [IN] ref 信号引用。
|
||||
* @return 时间轴指针，引用无效时返回 nullptr。
|
||||
*/
|
||||
const TimeAxis* Axis(const SignalRef& ref) const;
|
||||
|
||||
/**
|
||||
* @brief 获取指定信号的显示外观（只读）。
|
||||
* @param [IN] ref 信号引用。
|
||||
@@ -466,13 +571,13 @@ namespace jdi
|
||||
SignalStyle* Style(const SignalRef& ref);
|
||||
|
||||
/**
|
||||
* @brief 计算全部文件时间范围的并集下限。
|
||||
* @brief 计算全部分组、全部时间轴时间范围的并集下限。
|
||||
* @return 时间下限。
|
||||
*/
|
||||
double MinTime() const;
|
||||
|
||||
/**
|
||||
* @brief 计算全部文件时间范围的并集上限。
|
||||
* @brief 计算全部分组、全部时间轴时间范围的并集上限。
|
||||
* @return 时间上限。
|
||||
*/
|
||||
double MaxTime() const;
|
||||
@@ -490,10 +595,10 @@ namespace jdi
|
||||
void SetSelected(const SignalRef& ref) { m_selected = ref; }
|
||||
|
||||
/**
|
||||
* @brief 在数据层移除某文件之前，按旧下标修正选中引用。
|
||||
* @param [IN] fileIndex 即将被移除的文件下标。
|
||||
* @brief 在数据层移除某分组之前，按旧下标修正选中引用。
|
||||
* @param [IN] groupIndex 即将被移除的分组下标。
|
||||
*/
|
||||
void RemapSelectionAfterFileRemoval(int fileIndex);
|
||||
void RemapSelectionAfterGroupRemoval(int groupIndex);
|
||||
|
||||
/**
|
||||
* @brief 校验选中引用是否仍指向存在的信号，失效则取消选中。
|
||||
@@ -502,8 +607,8 @@ namespace jdi
|
||||
bool ValidateSelection();
|
||||
|
||||
private:
|
||||
std::vector<DataFile> m_files; /**< 已加载文件集合。 */
|
||||
SignalRef m_selected; /**< 当前选中信号（跨标签页共享）。 */
|
||||
std::vector<SignalGroup> m_groups; /**< 已加载信号分组集合。 */
|
||||
SignalRef m_selected; /**< 当前选中信号（跨标签页共享）。 */
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -712,14 +817,14 @@ namespace jdi
|
||||
*
|
||||
* 加载完成后全部采样值已在内存中，本函数只查询内存数据，与源文件无关。
|
||||
*
|
||||
* @param [IN] file 信号所属的已加载数据分组（提供时间轴）。
|
||||
* @param [IN] axis 该信号使用的时间轴。
|
||||
* @param [IN] signal 目标信号。
|
||||
* @param [IN] time 采样时刻。
|
||||
* @param [IN] interpolate 是否在相邻采样点之间做线性插值。
|
||||
* @param [OUT] value 输出采样值，缺失时为 NaN。
|
||||
* @return 时间点落在数据范围内且取到有效值返回 true。
|
||||
*/
|
||||
bool SampleSignalAt(const DataFile& file, const SignalData& signal, double time, bool interpolate,
|
||||
bool SampleSignalAt(const TimeAxis& axis, const SignalData& signal, double time, bool interpolate,
|
||||
double& value);
|
||||
|
||||
/**
|
||||
@@ -732,15 +837,15 @@ namespace jdi
|
||||
* 否则读数会与看到的波形不一致。
|
||||
* ⚠️ 系数 / 绝对值 / 垂直镜像 / `offsetY` 不在这里处理，由 `ApplyDrawTransform` 负责。
|
||||
*
|
||||
* @param [IN] file 信号所属的已加载数据分组（提供时间轴）。
|
||||
* @param [IN] axis 该信号使用的时间轴。
|
||||
* @param [IN] signal 目标信号。
|
||||
* @param [IN] style 显示外观（只用 `mirrorHorizontal`）。
|
||||
* @param [IN] style 显示外观（只用 `mirrorHorizontal` 与 `offsetTime`）。
|
||||
* @param [IN] time 采样时刻。
|
||||
* @param [IN] interpolate 是否在相邻采样点之间做线性插值。
|
||||
* @param [OUT] value 输出采样值，缺失时为 NaN。
|
||||
* @return 时间点落在数据范围内且取到有效值返回 true。
|
||||
*/
|
||||
bool SampleDisplayedSignalAt(const DataFile& file, const SignalData& signal,
|
||||
bool SampleDisplayedSignalAt(const TimeAxis& axis, const SignalData& signal,
|
||||
const SignalStyle& style, double time, bool interpolate, double& value);
|
||||
|
||||
/**
|
||||
@@ -827,12 +932,12 @@ namespace jdi
|
||||
bool throttle = false);
|
||||
|
||||
/**
|
||||
* @brief 在指定文件的时间轴上查找与给定时刻最接近的采样点。
|
||||
* @param [IN] file 目标文件。
|
||||
* @brief 在给定时间轴上查找与给定时刻最接近的采样点。
|
||||
* @param [IN] axis 目标时间轴。
|
||||
* @param [IN] time 采样时刻。
|
||||
* @return 采样点下标，文件为空时返回 -1。
|
||||
* @return 采样点下标，时间轴为空时返回 -1。
|
||||
*/
|
||||
int FindNearestSample(const DataFile& file, double time);
|
||||
int FindNearestSample(const TimeAxis& axis, double time);
|
||||
|
||||
/**
|
||||
* @brief 单个标签页的独立视图配置（信号可见性、网格划分与视图范围）。
|
||||
@@ -865,10 +970,10 @@ namespace jdi
|
||||
|
||||
/**
|
||||
* @brief 在数据层移除某文件之前，按旧下标修正本配置（不重建网格）。
|
||||
* @param [IN] fileIndex 即将被移除的文件下标。
|
||||
* @note 调用顺序必须为：各标签页 RemapAfterFileRemoval → 数据层 RemoveFile → 各标签页 SyncToDataSet。
|
||||
* @param [IN] groupIndex 即将被移除的分组下标。
|
||||
* @note 调用顺序必须为：各标签页 RemapAfterGroupRemoval → 数据层 RemoveFile → 各标签页 SyncToDataSet。
|
||||
*/
|
||||
void RemapAfterFileRemoval(int fileIndex);
|
||||
void RemapAfterGroupRemoval(int groupIndex);
|
||||
|
||||
/**
|
||||
* @brief 在数据层移除某条信号之前，按旧下标修正本配置（不重建网格）。
|
||||
@@ -876,12 +981,12 @@ namespace jdi
|
||||
* 会删除该信号的可见性记录与网格归属，并把同一文件内位于其后的引用下标前移一位。
|
||||
* 若某个网格因此变空则一并移除（与“取消勾选后空网格消失”的策略一致）。
|
||||
*
|
||||
* @param [IN] fileIndex 信号所属文件下标。
|
||||
* @param [IN] groupIndex 信号所属分组下标。
|
||||
* @param [IN] signalIndex 即将被移除的信号下标。
|
||||
* @note 调用顺序必须为：各标签页 RemapAfterSignalRemoval → 数据层修正选中 →
|
||||
* 数据层 RemoveSignal → 各标签页 SyncToDataSet。
|
||||
*/
|
||||
void RemapAfterSignalRemoval(int fileIndex, int signalIndex);
|
||||
void RemapAfterSignalRemoval(int groupIndex, int signalIndex);
|
||||
|
||||
/**
|
||||
* @brief 判断指定信号是否可见。
|
||||
@@ -905,10 +1010,10 @@ namespace jdi
|
||||
|
||||
/**
|
||||
* @brief 设置某个文件全部信号的可见性，并同步网格划分。
|
||||
* @param [IN] fileIndex 文件下标。
|
||||
* @param [IN] groupIndex 分组下标。
|
||||
* @param [IN] visible 目标可见状态。
|
||||
*/
|
||||
void SetFileVisible(int fileIndex, bool visible);
|
||||
void SetGroupVisible(int groupIndex, bool visible);
|
||||
|
||||
/**
|
||||
* @brief 设置全部信号可见性，并同步网格划分。
|
||||
@@ -924,17 +1029,17 @@ namespace jdi
|
||||
|
||||
/**
|
||||
* @brief 判断某文件是否存在可见信号。
|
||||
* @param [IN] fileIndex 文件下标。
|
||||
* @param [IN] groupIndex 分组下标。
|
||||
* @return 存在可见信号返回 true。
|
||||
*/
|
||||
bool FileHasVisible(int fileIndex) const;
|
||||
bool GroupHasVisible(int groupIndex) const;
|
||||
|
||||
/**
|
||||
* @brief 判断某文件是否全部信号可见。
|
||||
* @param [IN] fileIndex 文件下标。
|
||||
* @param [IN] groupIndex 分组下标。
|
||||
* @return 全部可见且至少有一条信号返回 true。
|
||||
*/
|
||||
bool FileAllVisible(int fileIndex) const;
|
||||
bool GroupAllVisible(int groupIndex) const;
|
||||
|
||||
/**
|
||||
* @brief 判断是否存在任何可见信号。
|
||||
@@ -1010,10 +1115,10 @@ namespace jdi
|
||||
* 数据层在下标 `insertPos` 处插入了一条信号，因此本页可见性表需插入一列，
|
||||
* 且所有指向该文件、下标不小于 `insertPos` 的信号引用都要后移一位。
|
||||
*
|
||||
* @param [IN] fileIndex 发生插入的文件下标。
|
||||
* @param [IN] groupIndex 发生插入的分组下标。
|
||||
* @param [IN] insertPos 新信号的下标。
|
||||
*/
|
||||
void RemapAfterSignalInsert(int fileIndex, int insertPos);
|
||||
void RemapAfterSignalInsert(int groupIndex, int insertPos);
|
||||
|
||||
/**
|
||||
* @brief 把某信号所在的网格移动到另一信号所在网格的下方（紧邻其后）。
|
||||
@@ -1046,16 +1151,16 @@ namespace jdi
|
||||
void RenameLanes();
|
||||
|
||||
/** * @brief 查询某文件的分组是否处于折叠状态。
|
||||
* @param [IN] fileIndex 文件下标。
|
||||
* @param [IN] groupIndex 分组下标。
|
||||
* @return 折叠状态。
|
||||
*/
|
||||
bool IsCollapsed(int fileIndex) const;
|
||||
bool IsCollapsed(int groupIndex) const;
|
||||
|
||||
/**
|
||||
* @brief 切换某文件分组的折叠状态。
|
||||
* @param [IN] fileIndex 文件下标。
|
||||
* @param [IN] groupIndex 分组下标。
|
||||
*/
|
||||
void ToggleCollapsed(int fileIndex);
|
||||
void ToggleCollapsed(int groupIndex);
|
||||
|
||||
/**
|
||||
* @brief 设置「新出现的文件分组是否默认折起」。
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
#ifndef __DATA_TABLE_HPP__
|
||||
#define __DATA_TABLE_HPP__
|
||||
|
||||
#include <cstddef>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace jdi
|
||||
{
|
||||
|
||||
/**
|
||||
* @brief 内存中的**列优先**数据表（与具体文件格式无关）。
|
||||
*
|
||||
* 这是「从任意格式读出来的原始格子」：一行是表头，其余是各列的数值。
|
||||
* 它**不是**应用的数据模型（不含时间轴语义、不含信号名规范化），
|
||||
* 只是各格式加载器（CSV / MF4 / 以后更多格式）与数据模型之间的中转结构。
|
||||
*
|
||||
* 采用列优先（每列一整块连续内存）而不是行优先的二维数组，原因有二：
|
||||
* 1. 大型文件（百万行级）若按行存储会产生上百万次独立堆分配，
|
||||
* 每行还要额外承担 vector 的控制块与容量对齐开销，实测内存放大接近 1.5 倍；
|
||||
* 2. 构建信号时可以直接把整列**移动**进 `SignalData`，不再逐元素拷贝。
|
||||
*/
|
||||
struct DataTable
|
||||
{
|
||||
std::vector<std::wstring> headers; /**< 列名（已去除引号与首尾空白）。 */
|
||||
std::vector<std::vector<double>> columns; /**< 列优先数值矩阵：columns[列][行]，缺失处为 NaN。 */
|
||||
std::size_t rowCount = 0; /**< 有效数据行数。 */
|
||||
wchar_t delimiter = L','; /**< 实际使用的分隔符（仅文本格式有意义）。 */
|
||||
unsigned long long sourceBytes = 0; /**< 源文件字节数（用于按比例预留容量）。 */
|
||||
|
||||
/**
|
||||
* @brief 判断解析结果是否包含可用的表格数据。
|
||||
* @return 存在列名且存在数据行时返回 true。
|
||||
*/
|
||||
bool HasData() const { return !headers.empty() && (rowCount > 0) && (columns.size() >= headers.size()); }
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 加载进度信息。
|
||||
*
|
||||
* 解析阶段会携带真实的"已读 / 总字节数"；列重组与统计阶段没有字节可计，
|
||||
* 此时 `hasBytes` 为 false，界面应只展示百分比。
|
||||
*/
|
||||
struct LoadProgressInfo
|
||||
{
|
||||
double ratio = 0.0; /**< 0-1 总体完成比例。 */
|
||||
unsigned long long bytesRead = 0; /**< 已读取字节数。 */
|
||||
unsigned long long totalBytes = 0; /**< 文件总字节数。 */
|
||||
bool hasBytes = false; /**< 上述字节数字段是否有效。 */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 加载进度回调。
|
||||
*
|
||||
* 在解析过程中按块回调；返回 false 表示请求取消，解析会尽快停止并返回失败。
|
||||
*/
|
||||
using LoadProgress = std::function<bool(const LoadProgressInfo& info)>;
|
||||
|
||||
/**
|
||||
* @brief 一组**共享同一时间轴**的数据列（一个「时间轴块」）。
|
||||
*
|
||||
* 一个源文件可以包含多个这样的块：CSV 里每个 `time` 列都会开启一个新块，
|
||||
* MF4 里每个测量通道组（CG）是一个块。块内的各列长度一致（都等于本块的行数）。
|
||||
*/
|
||||
struct TableBlock
|
||||
{
|
||||
std::wstring timeHeader; /**< 本块时间列的列名（原样保留，如 `time`）。 */
|
||||
DataTable table; /**< 本块的列集合（**含**时间列本身）。 */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 一个源文件加载后的全部内容（可能包含多个时间轴块）。
|
||||
*
|
||||
* ⚠️ 这是「加载器 → 数据模型」的唯一接口：加载器只负责把文件读成
|
||||
* `LoadedSource`（纯格子，无应用语义），`BuildSignalGroup` 再把它规范化为
|
||||
* `SignalGroup`（含时间轴去重、信号命名、调色板等应用语义）。
|
||||
* 新增文件格式时**只需新增一个加载器**，数据模型与界面代码完全不用改。
|
||||
*/
|
||||
struct LoadedSource
|
||||
{
|
||||
std::wstring sourceName; /**< 源文件名（不含目录，含扩展名）。 */
|
||||
std::vector<TableBlock> blocks; /**< 时间轴块集合（至少一个）。 */
|
||||
|
||||
/** @brief 是否包含可用的数据。 */
|
||||
bool HasData() const
|
||||
{
|
||||
for (const TableBlock& block : blocks)
|
||||
{
|
||||
if (block.table.HasData())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace jdi
|
||||
|
||||
#endif // __DATA_TABLE_HPP__
|
||||
@@ -0,0 +1,36 @@
|
||||
#ifndef __MF4_LOADER_HPP__
|
||||
#define __MF4_LOADER_HPP__
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "DataTable.hpp"
|
||||
|
||||
namespace jdi
|
||||
{
|
||||
|
||||
/**
|
||||
* @brief 读取并解析一个 ASAM MDF v4（`.mf4` / `.mdf`）测量文件。
|
||||
*
|
||||
* 只解析**绘制需要的那部分**：头块版本、数据组（DG）→ 通道组（CG）→ 通道（CN）/换算（CC），
|
||||
* 以及每个通道组的原始记录；字符串/字节数组通道、压缩数据块（DZ/HZ）与 MIME 通道一律跳过。
|
||||
*
|
||||
* **时间轴**：MDF 的每个通道组（CG）自带一个时间基准。本加载器把每个 CG 输出为一个
|
||||
* 时间轴块（`TableBlock`）：块的时间列取自该组的**时间主通道**（`cn_sync_type == 1`，
|
||||
* 退回名为 `time`/`t` 的通道，再退回第一个数值通道），其余数值通道作为该块的信号列。
|
||||
* 内容完全相同的时间轴在数据模型层会被合并（见 `BuildSignalGroup`）。
|
||||
*
|
||||
* 支持的通道编码：无符号/有符号整数（1–64 位，任意位偏移）与 IEEE-754 浮点（32/64 位）。
|
||||
* 支持的换算：无换算、线性（`phys = c0 + c1 * raw`）。其它换算按“无换算”处理。
|
||||
*
|
||||
* @param [IN] filePath MDF 文件完整路径。
|
||||
* @param [OUT] source 解析结果（每个通道组一个时间轴块）。
|
||||
* @param [OUT] error 失败原因描述（成功时清空）。
|
||||
* @param [IN] progress 进度回调（按字节比例），可为空。
|
||||
* @return 解析成功返回 true。
|
||||
*/
|
||||
bool LoadMf4Source(const std::wstring& filePath, LoadedSource& source, std::wstring& error,
|
||||
const LoadProgress& progress = LoadProgress());
|
||||
|
||||
} // namespace jdi
|
||||
|
||||
#endif // __MF4_LOADER_HPP__
|
||||
@@ -1,9 +1,10 @@
|
||||
#include "CsvTable.hpp"
|
||||
#include "CsvLoader.hpp"
|
||||
|
||||
#include "Utf8Util.hpp"
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
@@ -236,7 +237,7 @@ namespace jdi
|
||||
* @param [IN] end 行结束指针（不包含）。
|
||||
* @return 解析可以继续返回 true；表头非法需要中止时返回 false。
|
||||
*/
|
||||
bool HandleLine(CsvTable& table, ParseState& state, const char* begin, const char* end)
|
||||
bool HandleLine(DataTable& table, ParseState& state, const char* begin, const char* end)
|
||||
{
|
||||
const char* lineEnd = end;
|
||||
while (lineEnd > begin && lineEnd[-1] == '\r')
|
||||
@@ -280,7 +281,7 @@ namespace jdi
|
||||
}
|
||||
|
||||
// 列优先存储：一次性为每列预留容量，避免逐行扩容（百万行时复制代价可观）。
|
||||
const std::size_t capacity = EstimateRowCapacity(table.fileBytes);
|
||||
const std::size_t capacity = EstimateRowCapacity(table.sourceBytes);
|
||||
table.columns.assign(table.headers.size(), std::vector<double>());
|
||||
for (std::vector<double>& column : table.columns)
|
||||
{
|
||||
@@ -329,12 +330,166 @@ namespace jdi
|
||||
++table.rowCount;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool LoadCsvTable(const std::wstring& filePath, CsvTable& table, std::wstring& error,
|
||||
const CsvProgress& progress)
|
||||
/**
|
||||
* @brief 判断列名是否为一个时间轴的列名。
|
||||
*
|
||||
* 应用的约定：**只有名为 `time`（以及少量等价写法）的列是特殊的时间轴列**，
|
||||
* 其余列一律视为数据信号（不做单位/量纲推断等元数据解析）。
|
||||
*
|
||||
* @param [IN] header 原始列名。
|
||||
* @return 该列是时间轴列返回 true。
|
||||
*/
|
||||
bool LooksLikeTimeHeader(const std::wstring& header)
|
||||
{
|
||||
const std::wstring text = ToLowerAscii(Trim(header));
|
||||
if (text.empty())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return text == L"t" || text == L"time" || text == L"timestamp" ||
|
||||
text == L"simulation time" || text == L"时间" || text == L"时间轴";
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 把整表按「时间列」切分为若干时间轴块。
|
||||
*
|
||||
* 每遇到一个时间列就开启新块；它之后直到下一个时间列之前的非时间列都属于该块。
|
||||
* 首个时间列之前若存在数据列（例如表中根本没有任何名为 `time` 的列、或数据列出现在
|
||||
* 第一个时间列之前），这些列并入**第一个块**，并把第一列当作该块的时间轴
|
||||
*（保持旧版「回退到第一列」的行为）。
|
||||
*
|
||||
* ⚠️ 每个块会按**自己**的时间列截断：较短的时间轴在其数据区提前结束（其余位置为空），
|
||||
* 因此各块的行数可以不同，列向量会收缩到本块真正有时间的那些行。
|
||||
*
|
||||
* @param [IN,OUT] table 整表（列会被移动到各个块中）。
|
||||
* @param [OUT] blocks 切分结果。
|
||||
*/
|
||||
void SplitIntoBlocks(DataTable& table, std::vector<TableBlock>& blocks)
|
||||
{
|
||||
const std::size_t columnCount = table.headers.size();
|
||||
|
||||
// 找出所有时间列下标（按出现顺序）。
|
||||
std::vector<std::size_t> timeColumns;
|
||||
for (std::size_t column = 0; column < columnCount; ++column)
|
||||
{
|
||||
if (LooksLikeTimeHeader(table.headers[column]))
|
||||
{
|
||||
timeColumns.push_back(column);
|
||||
}
|
||||
}
|
||||
|
||||
// 一个时间列都没有：整表当作单块，并把第一列当作时间轴（旧版回退行为）。
|
||||
if (timeColumns.empty())
|
||||
{
|
||||
if (columnCount < 2)
|
||||
{
|
||||
return; // 只有一列又没有时间列：没有可用的数据
|
||||
}
|
||||
timeColumns.push_back(0);
|
||||
}
|
||||
|
||||
// 每个时间列开启一个块；块的成员 = [时间列, 下一个时间列)。
|
||||
for (std::size_t index = 0; index < timeColumns.size(); ++index)
|
||||
{
|
||||
const std::size_t timeColumn = timeColumns[index];
|
||||
const std::size_t blockEnd = (index + 1 < timeColumns.size()) ? timeColumns[index + 1]
|
||||
: columnCount;
|
||||
if (timeColumn >= columnCount || blockEnd <= timeColumn + 1)
|
||||
{
|
||||
continue; // 该时间列之后没有任何数据列
|
||||
}
|
||||
|
||||
TableBlock block;
|
||||
block.timeHeader = table.headers[timeColumn];
|
||||
block.table.delimiter = table.delimiter;
|
||||
block.table.sourceBytes = table.sourceBytes;
|
||||
|
||||
block.table.headers.reserve(blockEnd - timeColumn);
|
||||
for (std::size_t column = timeColumn; column < blockEnd; ++column)
|
||||
{
|
||||
block.table.headers.push_back(table.headers[column]);
|
||||
block.table.columns.push_back(std::move(table.columns[column]));
|
||||
}
|
||||
block.table.rowCount = table.rowCount;
|
||||
blocks.push_back(std::move(block));
|
||||
}
|
||||
|
||||
// 首个时间列之前若还有数据列（非时间列），并入第一个块，并让第一列充当时间轴。
|
||||
if (!blocks.empty() && timeColumns.front() > 0 && blocks.size() >= 1)
|
||||
{
|
||||
TableBlock& first = blocks.front();
|
||||
std::vector<std::size_t> prepended;
|
||||
for (std::size_t column = 0; column < timeColumns.front(); ++column)
|
||||
{
|
||||
first.table.headers.push_back(table.headers[column]);
|
||||
first.table.columns.push_back(std::move(table.columns[column]));
|
||||
prepended.push_back(column);
|
||||
}
|
||||
if (!prepended.empty())
|
||||
{
|
||||
// 把原时间列移到 block.table 的最前面（保持 `columns[0]` = 时间列 的约定）。
|
||||
std::rotate(first.table.headers.begin(),
|
||||
first.table.headers.begin() + static_cast<std::ptrdiff_t>(prepended.size()),
|
||||
first.table.headers.end());
|
||||
std::rotate(first.table.columns.begin(),
|
||||
first.table.columns.begin() + static_cast<std::ptrdiff_t>(prepended.size()),
|
||||
first.table.columns.end());
|
||||
first.timeHeader = first.table.headers.front();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 按本块自己的时间列截断（丢掉尾部没有时间的行），并计算有效时间点数量。
|
||||
*
|
||||
* 多时间轴文件里各块长度不同：较短的时间轴在数据区提前结束，其余行的时间是空的。
|
||||
* 这里把列向量收缩到最后一行「时间列有效」的位置，既省内存，也让后续的
|
||||
* `lower_bound`（依赖时间单调）建立在干净的数据上。
|
||||
*
|
||||
* @param [IN,OUT] block 目标块。
|
||||
* @return 有效时间点数量。
|
||||
*/
|
||||
std::size_t TrimBlockRows(TableBlock& block)
|
||||
{
|
||||
if (block.table.columns.empty())
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
const std::vector<double>& time = block.table.columns.front();
|
||||
std::size_t lastValid = 0;
|
||||
std::size_t finiteCount = 0;
|
||||
for (std::size_t row = 0; row < time.size(); ++row)
|
||||
{
|
||||
if (std::isfinite(time[row]))
|
||||
{
|
||||
lastValid = row + 1;
|
||||
++finiteCount;
|
||||
}
|
||||
}
|
||||
if (lastValid == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
if (lastValid < block.table.rowCount)
|
||||
{
|
||||
for (std::vector<double>& column : block.table.columns)
|
||||
{
|
||||
if (column.size() > lastValid)
|
||||
{
|
||||
column.resize(lastValid);
|
||||
}
|
||||
}
|
||||
block.table.rowCount = lastValid;
|
||||
}
|
||||
return finiteCount;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
bool LoadCsvSource(const std::wstring& filePath, LoadedSource& source, std::wstring& error,
|
||||
const LoadProgress& progress)
|
||||
{
|
||||
table = CsvTable();
|
||||
source = LoadedSource();
|
||||
error.clear();
|
||||
|
||||
FILE* file = nullptr;
|
||||
@@ -343,7 +498,12 @@ namespace jdi
|
||||
{
|
||||
return false;
|
||||
}
|
||||
table.fileBytes = fileSize;
|
||||
|
||||
const std::size_t slashPos = filePath.find_last_of(L"\\/");
|
||||
source.sourceName = (slashPos == std::wstring::npos) ? filePath : filePath.substr(slashPos + 1);
|
||||
|
||||
DataTable table;
|
||||
table.sourceBytes = fileSize;
|
||||
|
||||
ParseState state;
|
||||
std::string staging;
|
||||
@@ -397,12 +557,12 @@ namespace jdi
|
||||
|
||||
if (progress)
|
||||
{
|
||||
CsvProgressInfo info;
|
||||
LoadProgressInfo info;
|
||||
info.bytesRead = state.bytesConsumed;
|
||||
info.totalBytes = fileSize;
|
||||
info.hasBytes = true;
|
||||
info.ratio = (fileSize > 0) ? static_cast<double>(state.bytesConsumed) /
|
||||
static_cast<double>(fileSize)
|
||||
info.ratio = (fileSize > 0) ? (static_cast<double>(state.bytesConsumed) /
|
||||
static_cast<double>(fileSize))
|
||||
: 0.0;
|
||||
if (info.ratio > 1.0)
|
||||
{
|
||||
@@ -415,14 +575,16 @@ namespace jdi
|
||||
}
|
||||
}
|
||||
|
||||
// 处理文件末尾没有换行符的最后一行。
|
||||
// 处理文件末尾没有换行的最后一行。
|
||||
if (!cancelled && !fatal && !state.pending.empty())
|
||||
{
|
||||
if (!HandleLine(table, state, state.pending.data(), state.pending.data() + state.pending.size()))
|
||||
{
|
||||
fatal = true;
|
||||
}
|
||||
state.pending.clear();
|
||||
}
|
||||
|
||||
std::fclose(file);
|
||||
|
||||
if (cancelled)
|
||||
@@ -430,16 +592,43 @@ namespace jdi
|
||||
error = L"已取消加载。";
|
||||
return false;
|
||||
}
|
||||
if (table.headers.empty())
|
||||
if (fatal || !table.HasData())
|
||||
{
|
||||
error = fatal ? L"表头为空，无法解析列名。" : L"未从文件中解析出有效数据行。";
|
||||
error = L"未能从文件中解析出有效数据表。";
|
||||
return false;
|
||||
}
|
||||
if (!table.HasData())
|
||||
|
||||
// 按时间列切分为多个时间轴块，并各自按自己的时间列截断。
|
||||
SplitIntoBlocks(table, source.blocks);
|
||||
if (source.blocks.empty())
|
||||
{
|
||||
error = L"未从文件中解析出有效数据行。";
|
||||
error = L"未发现任何时间轴列与数据列的组合。";
|
||||
return false;
|
||||
}
|
||||
|
||||
// 丢弃没有任何有效时间点的块；若全部无效则报错。
|
||||
std::vector<TableBlock> kept;
|
||||
kept.reserve(source.blocks.size());
|
||||
for (TableBlock& block : source.blocks)
|
||||
{
|
||||
if (TrimBlockRows(block) >= 2)
|
||||
{
|
||||
kept.push_back(std::move(block));
|
||||
}
|
||||
}
|
||||
if (kept.empty())
|
||||
{
|
||||
error = L"时间轴列的有效数值不足（至少需要 2 个）。";
|
||||
return false;
|
||||
}
|
||||
source.blocks = std::move(kept);
|
||||
|
||||
if (progress)
|
||||
{
|
||||
LoadProgressInfo info;
|
||||
info.ratio = 1.0;
|
||||
progress(info);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
#include "DataLoader.hpp"
|
||||
|
||||
#include "CsvLoader.hpp"
|
||||
#include "Mf4Loader.hpp"
|
||||
#include "Utf8Util.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
namespace jdi
|
||||
{
|
||||
|
||||
namespace
|
||||
{
|
||||
/** @brief 取小写扩展名（含点）。 */
|
||||
std::wstring ExtensionOf(const std::wstring& filePath)
|
||||
{
|
||||
const std::size_t dot = filePath.find_last_of(L'.');
|
||||
if (dot == std::wstring::npos)
|
||||
{
|
||||
return std::wstring();
|
||||
}
|
||||
return ToLowerAscii(filePath.substr(dot));
|
||||
}
|
||||
} // namespace
|
||||
|
||||
bool IsSupportedSignalFile(const std::wstring& filePath)
|
||||
{
|
||||
const std::wstring extension = ExtensionOf(filePath);
|
||||
return extension == L".csv" || extension == L".txt" || extension == L".mf4" ||
|
||||
extension == L".mdf" || extension == L".dat";
|
||||
}
|
||||
|
||||
const wchar_t* SignalFileDialogFilter()
|
||||
{
|
||||
// GetOpenFileNameW 要求：每个过滤器一对「说明\0通配符\0」，最后以空字符串结束。
|
||||
return L"测量数据文件 (*.csv;*.txt;*.mf4;*.mdf;*.dat)\0*.csv;*.txt;*.mf4;*.mdf;*.dat\0"
|
||||
L"CSV 文本 (*.csv;*.txt)\0*.csv;*.txt\0"
|
||||
L"ASAM MDF v4 (*.mf4;*.mdf)\0*.mf4;*.mdf\0"
|
||||
L"全部文件 (*.*)\0*.*\0";
|
||||
}
|
||||
|
||||
bool LoadSignalSource(const std::wstring& filePath, LoadedSource& source, std::wstring& error,
|
||||
const LoadProgress& progress)
|
||||
{
|
||||
const std::wstring extension = ExtensionOf(filePath);
|
||||
if (extension == L".mf4" || extension == L".mdf")
|
||||
{
|
||||
return LoadMf4Source(filePath, source, error, progress);
|
||||
}
|
||||
// 其余（含未知扩展名）一律按 CSV 文本尝试解析：文本格式的容错性最好，
|
||||
// 而未知扩展名在「打开文件」对话框里也只能由用户显式指定。
|
||||
return LoadCsvSource(filePath, source, error, progress);
|
||||
}
|
||||
|
||||
} // namespace jdi
|
||||
+362
-341
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,820 @@
|
||||
#include "Mf4Loader.hpp"
|
||||
|
||||
#include "Utf8Util.hpp"
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace jdi
|
||||
{
|
||||
|
||||
namespace
|
||||
{
|
||||
const double kMissingValue = std::numeric_limits<double>::quiet_NaN(); /**< 缺失值占位。 */
|
||||
const std::size_t kReadChunkBytes = 4u * 1024u * 1024u; /**< 数据区流式读取块大小。 */
|
||||
const std::size_t kMaxChannelsPerGroup = 4096; /**< 单个通道组的通道数上限（防损坏文件死循环）。 */
|
||||
const std::size_t kMaxGroups = 65536; /**< 数据组数量上限。 */
|
||||
|
||||
/** MDF 块头固定长度（id + reserved + length + link_count）。 */
|
||||
const std::size_t kBlockHeaderBytes = 24;
|
||||
|
||||
/** @brief 通道数据类型（`cn_data_type`）。 */
|
||||
enum class DataType : int
|
||||
{
|
||||
UINT_LE = 0,
|
||||
UINT_BE = 1,
|
||||
INT_LE = 2,
|
||||
INT_BE = 3,
|
||||
FLOAT_LE = 4,
|
||||
FLOAT_BE = 5,
|
||||
STRING_LATIN1 = 6,
|
||||
STRING_UTF8 = 7,
|
||||
STRING_UTF16_LE = 8,
|
||||
STRING_UTF16_BE = 9,
|
||||
BYTE_ARRAY = 10,
|
||||
MIME_SAMPLE = 11,
|
||||
MIME_STREAM = 12
|
||||
};
|
||||
|
||||
/** @brief 换算类型（`cc_type`）中我们支持的子集。 */
|
||||
enum class ConversionType : int
|
||||
{
|
||||
NONE = 0, /**< 无换算（恒等）。 */
|
||||
LINEAR = 1, /**< 线性：`phys = c0 + c1 * raw`。 */
|
||||
RATIONAL = 2 /**< 有理式（未支持，按恒等处理）。 */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 只读的 MDF 文件访问器（按需 seek + read，不把整个文件读进内存）。
|
||||
*/
|
||||
class MdfFile
|
||||
{
|
||||
public:
|
||||
~MdfFile() { Close(); }
|
||||
|
||||
bool Open(const std::wstring& path, std::wstring& error)
|
||||
{
|
||||
m_file = _wfopen(path.c_str(), L"rb");
|
||||
if (m_file == nullptr)
|
||||
{
|
||||
error = L"无法打开文件，请确认路径与访问权限。";
|
||||
return false;
|
||||
}
|
||||
if (_fseeki64(m_file, 0, SEEK_END) != 0)
|
||||
{
|
||||
error = L"无法定位文件末尾。";
|
||||
return false;
|
||||
}
|
||||
const long long size = _ftelli64(m_file);
|
||||
if (size <= 0)
|
||||
{
|
||||
error = L"文件内容为空。";
|
||||
return false;
|
||||
}
|
||||
m_size = static_cast<std::uint64_t>(size);
|
||||
|
||||
// ID 块：0..7 = "MDF "，8..15 = 版本号，例如 "4.10 "。
|
||||
char id[8] = {};
|
||||
char version[8] = {};
|
||||
if (!ReadAt(0, id, sizeof(id)) || std::memcmp(id, "MDF", 3) != 0)
|
||||
{
|
||||
error = L"不是有效的 MDF 文件（缺少 MDF 标识）。";
|
||||
return false;
|
||||
}
|
||||
if (!ReadAt(8, version, sizeof(version)) || version[0] != '4')
|
||||
{
|
||||
error = L"仅支持 MDF v4 格式（当前文件不是 v4）。";
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void Close()
|
||||
{
|
||||
if (m_file != nullptr)
|
||||
{
|
||||
std::fclose(m_file);
|
||||
m_file = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
std::uint64_t Size() const { return m_size; }
|
||||
|
||||
/** @brief 读取一段原始字节。 */
|
||||
bool ReadAt(std::uint64_t offset, void* dst, std::size_t bytes) const
|
||||
{
|
||||
if (m_file == nullptr || offset + bytes > m_size)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (_fseeki64(m_file, static_cast<long long>(offset), SEEK_SET) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return std::fread(dst, 1, bytes, m_file) == bytes;
|
||||
}
|
||||
|
||||
/** @brief 读取一个小端标量（最多 8 字节）。越界返回 0。 */
|
||||
std::uint64_t Scalar(std::uint64_t offset, std::size_t bytes) const
|
||||
{
|
||||
unsigned char buffer[8] = {};
|
||||
if (bytes == 0 || bytes > 8 || !ReadAt(offset, buffer, bytes))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
std::uint64_t value = 0;
|
||||
for (std::size_t i = 0; i < bytes; ++i)
|
||||
{
|
||||
value |= static_cast<std::uint64_t>(buffer[i]) << (8u * i);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
std::uint32_t U32(std::uint64_t offset) const
|
||||
{
|
||||
return static_cast<std::uint32_t>(Scalar(offset, 4));
|
||||
}
|
||||
std::uint16_t U16(std::uint64_t offset) const
|
||||
{
|
||||
return static_cast<std::uint16_t>(Scalar(offset, 2));
|
||||
}
|
||||
std::uint8_t U8(std::uint64_t offset) const
|
||||
{
|
||||
return static_cast<std::uint8_t>(Scalar(offset, 1));
|
||||
}
|
||||
std::uint64_t U64(std::uint64_t offset) const { return Scalar(offset, 8); }
|
||||
|
||||
double F64(std::uint64_t offset) const
|
||||
{
|
||||
const std::uint64_t bits = U64(offset);
|
||||
double value = 0.0;
|
||||
std::memcpy(&value, &bits, sizeof(value));
|
||||
return value;
|
||||
}
|
||||
|
||||
/** @brief 读取块标识（4 字节 ASCII）。 */
|
||||
bool BlockId(std::uint64_t offset, char out[5]) const
|
||||
{
|
||||
out[0] = out[1] = out[2] = out[3] = '?';
|
||||
out[4] = '\0';
|
||||
return ReadAt(offset, out, 4);
|
||||
}
|
||||
|
||||
/** @brief 块总长度（含块头）。 */
|
||||
std::uint64_t BlockLength(std::uint64_t offset) const { return U64(offset + 8); }
|
||||
/** @brief 块内链接数量。 */
|
||||
std::uint64_t LinkCount(std::uint64_t offset) const { return U64(offset + 16); }
|
||||
/** @brief 第 `index` 个链接（绝对文件偏移，0 表示空）。 */
|
||||
std::uint64_t Link(std::uint64_t offset, std::uint64_t index) const
|
||||
{
|
||||
if (index >= LinkCount(offset))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return U64(offset + kBlockHeaderBytes + 8u * index);
|
||||
}
|
||||
/** @brief 块的数据段起始偏移。 */
|
||||
std::uint64_t DataOffset(std::uint64_t offset) const
|
||||
{
|
||||
return offset + kBlockHeaderBytes + 8u * LinkCount(offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 判断某个偏移是否为一个有效块的开头（且标识匹配）。
|
||||
* @param [IN] offset 候选偏移。
|
||||
* @param [IN] id 期望的 4 字节标识（如 "##CN"）；空字符串表示只校验偏移合法性。
|
||||
*/
|
||||
bool IsBlock(std::uint64_t offset, const char* id) const
|
||||
{
|
||||
if (offset == 0 || offset + kBlockHeaderBytes > m_size)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
char actual[5] = {};
|
||||
if (!BlockId(offset, actual))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (id != nullptr && id[0] != '\0' && std::memcmp(actual, id, 4) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return BlockLength(offset) >= kBlockHeaderBytes && offset + BlockLength(offset) <= m_size;
|
||||
}
|
||||
|
||||
/** @brief 读取 `##TX` / `##MD` 块里的文本（MDF 的 TEXT 块）。 */
|
||||
std::wstring TextBlock(std::uint64_t offset) const
|
||||
{
|
||||
std::wstring text;
|
||||
if (!IsBlock(offset, "##TX"))
|
||||
{
|
||||
return text;
|
||||
}
|
||||
const std::uint64_t data = DataOffset(offset);
|
||||
const std::uint64_t usable = BlockLength(offset) - (data - offset);
|
||||
if (usable < 2)
|
||||
{
|
||||
return text;
|
||||
}
|
||||
|
||||
// MDF 规范里 TX 的数据段是「长度 + 文本」，长度可能是字符数（UTF-16）或字节数
|
||||
//（UTF-8，MDF 4.1 起）。但部分工具（如 CANape 16）会**直接写 NUL 结尾的
|
||||
// 原始文本、不带长度前缀**，因此这里按「先按规范、再按裸文本回退」的顺序解析。
|
||||
if (usable >= 4)
|
||||
{
|
||||
const std::uint64_t declared = U32(data);
|
||||
if (declared > 0 && 4u + 2u * declared <= usable)
|
||||
{
|
||||
// 长度前缀 + UTF-16 代码单元。
|
||||
std::vector<char> buffer(static_cast<std::size_t>(2u * declared));
|
||||
if (!ReadAt(data + 4, buffer.data(), buffer.size()))
|
||||
{
|
||||
return text;
|
||||
}
|
||||
text.reserve(static_cast<std::size_t>(declared));
|
||||
for (std::uint64_t i = 0; i < declared; ++i)
|
||||
{
|
||||
const wchar_t c =
|
||||
static_cast<wchar_t>(static_cast<unsigned char>(buffer[2 * i]) |
|
||||
(static_cast<unsigned char>(buffer[2 * i + 1]) << 8));
|
||||
if (c == L'\0')
|
||||
{
|
||||
break;
|
||||
}
|
||||
text.push_back(c);
|
||||
}
|
||||
return text;
|
||||
}
|
||||
if (declared > 0 && 4u + declared <= usable)
|
||||
{
|
||||
// 长度前缀 + UTF-8 字节。
|
||||
std::vector<char> buffer(static_cast<std::size_t>(declared) + 1u, '\0');
|
||||
if (!ReadAt(data + 4, buffer.data(), static_cast<std::size_t>(declared)))
|
||||
{
|
||||
return text;
|
||||
}
|
||||
return Utf8ToWide(buffer.data(), static_cast<int>(declared));
|
||||
}
|
||||
}
|
||||
|
||||
// 回退：数据段直接是 NUL 结尾的文本（UTF-16 或 UTF-8）。
|
||||
std::vector<unsigned char> buffer(static_cast<std::size_t>(usable));
|
||||
if (!ReadAt(data, buffer.data(), buffer.size()))
|
||||
{
|
||||
return text;
|
||||
}
|
||||
const bool utf16 = (buffer.size() >= 2 && buffer[1] == 0 && buffer[0] != 0);
|
||||
if (utf16)
|
||||
{
|
||||
for (std::size_t i = 0; i + 1 < buffer.size(); i += 2)
|
||||
{
|
||||
const wchar_t c = static_cast<wchar_t>(buffer[i] | (buffer[i + 1] << 8));
|
||||
if (c == L'\0')
|
||||
{
|
||||
break;
|
||||
}
|
||||
text.push_back(c);
|
||||
}
|
||||
return text;
|
||||
}
|
||||
std::string raw;
|
||||
for (const unsigned char c : buffer)
|
||||
{
|
||||
if (c == '\0')
|
||||
{
|
||||
break;
|
||||
}
|
||||
raw += static_cast<char>(c);
|
||||
}
|
||||
return Utf8ToWide(raw.data(), static_cast<int>(raw.size()));
|
||||
}
|
||||
|
||||
private:
|
||||
FILE* m_file = nullptr;
|
||||
std::uint64_t m_size = 0;
|
||||
};
|
||||
|
||||
/** @brief 一个通道的读取方案（已从 CN 块解析出来）。 */
|
||||
struct ChannelSpec
|
||||
{
|
||||
std::wstring name; /**< 通道名（`cn_tx_name`）。 */
|
||||
std::size_t bitOffset = 0; /**< 记录内的起始位偏移（= byte_offset*8 + bit_offset）。 */
|
||||
std::size_t bitCount = 0; /**< 位宽。 */
|
||||
DataType dataType = DataType::UINT_LE; /**< 原始数据类型。 */
|
||||
bool allInvalid = false; /**< `cn_flags & 1`：整列无效。 */
|
||||
bool hasInvalidBit = false; /**< `cn_flags & 2`：有无效位。 */
|
||||
std::size_t invalidBitPos = 0; /**< 无效位的绝对位偏移。 */
|
||||
bool syncMaster = false; /**< `cn_sync_type == 1`：时间主通道。 */
|
||||
bool linearConversion = false; /**< 是否带线性换算。 */
|
||||
double offset = 0.0; /**< 线性换算常数项。 */
|
||||
double factor = 1.0; /**< 线性换算系数（无法换算时为 1）。 */
|
||||
/** 数值有效性：只有整数与浮点通道可以绘制。 */
|
||||
bool numeric = false;
|
||||
};
|
||||
|
||||
/** @brief 判断数据类型是否为可绘制的数值类型。 */
|
||||
bool IsNumericType(DataType type)
|
||||
{
|
||||
return type == DataType::UINT_LE || type == DataType::UINT_BE || type == DataType::INT_LE ||
|
||||
type == DataType::INT_BE || type == DataType::FLOAT_LE || type == DataType::FLOAT_BE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 按位从记录缓冲中取出一个数值。
|
||||
*
|
||||
* 支持 1–64 位整数（任意位偏移）与 32/64 位浮点（字节对齐）。
|
||||
*
|
||||
* @param [IN] record 记录起始指针。
|
||||
* @param [IN] recordBytes 记录长度（字节），用于边界检查。
|
||||
* @param [IN] spec 通道读取方案。
|
||||
* @return 原始数值；越界或类型不支持时返回 NaN。
|
||||
*/
|
||||
double DecodeRawValue(const unsigned char* record, std::size_t recordBytes, const ChannelSpec& spec)
|
||||
{
|
||||
const std::size_t bitEnd = spec.bitOffset + spec.bitCount;
|
||||
if (spec.bitCount == 0 || spec.bitCount > 64 || bitEnd > recordBytes * 8u)
|
||||
{
|
||||
return kMissingValue;
|
||||
}
|
||||
const std::size_t byteStart = spec.bitOffset / 8u;
|
||||
const std::size_t byteCount = (bitEnd - byteStart * 8u + 7u) / 8u;
|
||||
unsigned char buffer[9] = {};
|
||||
std::memcpy(buffer, record + byteStart, byteCount);
|
||||
|
||||
if (spec.dataType == DataType::FLOAT_LE || spec.dataType == DataType::FLOAT_BE)
|
||||
{
|
||||
if (spec.bitOffset % 8u != 0u || (spec.bitCount != 32u && spec.bitCount != 64u))
|
||||
{
|
||||
return kMissingValue;
|
||||
}
|
||||
if (spec.dataType == DataType::FLOAT_LE)
|
||||
{
|
||||
if (spec.bitCount == 32u)
|
||||
{
|
||||
std::uint32_t bits = 0;
|
||||
std::memcpy(&bits, buffer, 4);
|
||||
float value = 0.0f;
|
||||
std::memcpy(&value, &bits, 4);
|
||||
return static_cast<double>(value);
|
||||
}
|
||||
double value = 0.0;
|
||||
std::memcpy(&value, buffer, 8);
|
||||
return value;
|
||||
}
|
||||
if (spec.bitCount == 32u)
|
||||
{
|
||||
std::uint32_t bits = (static_cast<std::uint32_t>(buffer[0]) << 24) |
|
||||
(static_cast<std::uint32_t>(buffer[1]) << 16) |
|
||||
(static_cast<std::uint32_t>(buffer[2]) << 8) |
|
||||
static_cast<std::uint32_t>(buffer[3]);
|
||||
float value = 0.0f;
|
||||
std::memcpy(&value, &bits, 4);
|
||||
return static_cast<double>(value);
|
||||
}
|
||||
std::uint64_t bits = 0;
|
||||
for (int i = 0; i < 8; ++i)
|
||||
{
|
||||
bits = (bits << 8) | static_cast<std::uint64_t>(buffer[i]);
|
||||
}
|
||||
double value = 0.0;
|
||||
std::memcpy(&value, &bits, 8);
|
||||
return value;
|
||||
}
|
||||
|
||||
// 整数：先按字节序拼成一个 64 位无符号数，再按位偏移右移并解释符号。
|
||||
std::uint64_t raw = 0;
|
||||
if (spec.dataType == DataType::UINT_LE || spec.dataType == DataType::INT_LE)
|
||||
{
|
||||
for (std::size_t i = byteCount; i-- > 0;)
|
||||
{
|
||||
raw = (raw << 8) | static_cast<std::uint64_t>(buffer[i]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (std::size_t i = 0; i < byteCount; ++i)
|
||||
{
|
||||
raw = (raw << 8) | static_cast<std::uint64_t>(buffer[i]);
|
||||
}
|
||||
}
|
||||
const std::size_t shift = spec.bitOffset % 8u;
|
||||
raw >>= shift;
|
||||
if (spec.bitCount < 64u)
|
||||
{
|
||||
raw &= (1ull << spec.bitCount) - 1ull;
|
||||
}
|
||||
|
||||
const bool signedType = (spec.dataType == DataType::INT_LE || spec.dataType == DataType::INT_BE);
|
||||
if (signedType && spec.bitCount < 64u && (raw & (1ull << (spec.bitCount - 1u))) != 0u)
|
||||
{
|
||||
// 符号扩展。
|
||||
raw |= ~((1ull << spec.bitCount) - 1ull);
|
||||
}
|
||||
if (signedType)
|
||||
{
|
||||
return static_cast<double>(static_cast<std::int64_t>(raw));
|
||||
}
|
||||
return static_cast<double>(raw);
|
||||
}
|
||||
|
||||
/** @brief 解析一个 CN 块为读取方案。 */
|
||||
bool ParseChannel(const MdfFile& file, std::uint64_t cn, ChannelSpec& spec)
|
||||
{
|
||||
if (!file.IsBlock(cn, "##CN"))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
const std::uint64_t data = file.DataOffset(cn);
|
||||
const std::uint8_t type = file.U8(data + 0);
|
||||
const std::uint8_t sync = file.U8(data + 1);
|
||||
const std::uint8_t dataType = file.U8(data + 2);
|
||||
const std::uint8_t bitOffset = file.U8(data + 3);
|
||||
const std::uint32_t byteOffset = file.U32(data + 4);
|
||||
const std::uint32_t bitCount = file.U32(data + 8);
|
||||
const std::uint32_t flags = file.U32(data + 12);
|
||||
const std::uint32_t invalidBit = file.U32(data + 16);
|
||||
|
||||
spec.name = file.TextBlock(file.Link(cn, 2));
|
||||
spec.dataType = static_cast<DataType>(dataType);
|
||||
spec.bitCount = bitCount;
|
||||
spec.bitOffset = static_cast<std::size_t>(byteOffset) * 8u + bitOffset;
|
||||
spec.allInvalid = (flags & 0x1u) != 0u;
|
||||
spec.hasInvalidBit = (flags & 0x2u) != 0u;
|
||||
spec.invalidBitPos = invalidBit;
|
||||
spec.syncMaster = (sync == 1);
|
||||
|
||||
// 换算：只支持“无换算”与“线性”。
|
||||
const std::uint64_t cc = file.Link(cn, 4);
|
||||
if (file.IsBlock(cc, "##CC"))
|
||||
{
|
||||
const std::uint64_t ccData = file.DataOffset(cc);
|
||||
const std::uint8_t ccType = file.U8(ccData + 0);
|
||||
const std::uint16_t valCount = file.U16(ccData + 6);
|
||||
if (ccType == static_cast<std::uint8_t>(ConversionType::LINEAR) && valCount >= 2)
|
||||
{
|
||||
spec.linearConversion = true;
|
||||
spec.offset = file.F64(ccData + 24);
|
||||
spec.factor = file.F64(ccData + 32);
|
||||
if (spec.factor == 0.0 && spec.offset == 0.0)
|
||||
{
|
||||
// 换算表未填写：按恒等处理，避免整列变成 0。
|
||||
spec.linearConversion = false;
|
||||
spec.offset = 0.0;
|
||||
spec.factor = 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 通道类型 2 = 虚拟主通道（CANape 的时间轴），同样可以取值。
|
||||
spec.numeric = IsNumericType(spec.dataType) && spec.bitCount > 0 && spec.bitCount <= 64;
|
||||
(void)type;
|
||||
return true;
|
||||
}
|
||||
|
||||
/** @brief 在一条 `next` 链上迭代块偏移（带访问次数上限，避免损坏文件死循环）。 */
|
||||
template <typename Fn>
|
||||
void WalkChain(const MdfFile& file, std::uint64_t first, const char* expectedId, std::size_t limit,
|
||||
Fn&& visit)
|
||||
{
|
||||
std::uint64_t current = first;
|
||||
std::size_t guard = 0;
|
||||
while (current != 0 && guard++ < limit)
|
||||
{
|
||||
if (!file.IsBlock(current, expectedId))
|
||||
{
|
||||
break;
|
||||
}
|
||||
if (!visit(current))
|
||||
{
|
||||
break;
|
||||
}
|
||||
current = file.Link(current, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/** @brief 一个通道组（CG）解析出的时间轴 + 信号列。 */
|
||||
struct ChannelGroupData
|
||||
{
|
||||
std::wstring timeName; /**< 时间列名（主通道名或 `time`）。 */
|
||||
std::vector<ChannelSpec> channels; /**< 非时间通道。 */
|
||||
std::vector<double> time; /**< 时间轴数值。 */
|
||||
std::vector<std::vector<double>> values; /**< 每个非时间通道的采样值。 */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief 读取一个通道组的全部记录（流式，按 4MB 分块）。
|
||||
*
|
||||
* @param [IN] file 文件访问器。
|
||||
* @param [IN] dt 数据块偏移（`##DT`），记录从 `DataOffset(dt)` 开始连续存放。
|
||||
* @param [IN] cycles 记录条数。
|
||||
* @param [IN] recordBytes 单条记录字节数。
|
||||
* @param [IN,OUT] group 输出（`timeName`/`channels` 已填好，函数填充 `time`/`values`）。
|
||||
*/
|
||||
bool ReadChannelGroupRecords(const MdfFile& file, std::uint64_t dt, std::uint64_t cycles,
|
||||
std::size_t recordBytes, std::size_t masterIndex,
|
||||
ChannelGroupData& group)
|
||||
{
|
||||
if (cycles == 0 || recordBytes == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
const std::uint64_t dataStart = file.DataOffset(dt);
|
||||
const std::uint64_t payload = file.BlockLength(dt) - (dataStart - dt);
|
||||
if (payload < cycles * recordBytes)
|
||||
{
|
||||
return false; // 数据不足（损坏或带压缩）
|
||||
}
|
||||
|
||||
group.time.assign(static_cast<std::size_t>(cycles), kMissingValue);
|
||||
group.values.assign(group.channels.size(),
|
||||
std::vector<double>(static_cast<std::size_t>(cycles), kMissingValue));
|
||||
|
||||
std::vector<unsigned char> buffer(kReadChunkBytes);
|
||||
std::uint64_t done = 0;
|
||||
while (done < cycles)
|
||||
{
|
||||
const std::uint64_t remainingRecords = cycles - done;
|
||||
const std::uint64_t wantBytes = std::min<std::uint64_t>(
|
||||
remainingRecords * recordBytes, static_cast<std::uint64_t>(buffer.size()));
|
||||
const std::uint64_t wantRecords = wantBytes / recordBytes;
|
||||
if (wantRecords == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
const std::size_t bytes = static_cast<std::size_t>(wantRecords * recordBytes);
|
||||
if (!file.ReadAt(dataStart + done * recordBytes, buffer.data(), bytes))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
for (std::uint64_t r = 0; r < wantRecords; ++r)
|
||||
{
|
||||
const unsigned char* record = buffer.data() + r * recordBytes;
|
||||
const std::size_t row = static_cast<std::size_t>(done + r);
|
||||
|
||||
// 时间主通道。
|
||||
{
|
||||
const ChannelSpec& master = group.channels[masterIndex];
|
||||
double value = DecodeRawValue(record, recordBytes, master);
|
||||
if (master.allInvalid)
|
||||
{
|
||||
value = kMissingValue;
|
||||
}
|
||||
else if (master.hasInvalidBit)
|
||||
{
|
||||
const std::size_t byteIndex = master.invalidBitPos / 8u;
|
||||
if (byteIndex < recordBytes &&
|
||||
((record[byteIndex] >> (master.invalidBitPos % 8u)) & 1u) != 0u)
|
||||
{
|
||||
value = kMissingValue;
|
||||
}
|
||||
}
|
||||
if (std::isfinite(value))
|
||||
{
|
||||
value = master.linearConversion ? (master.offset + master.factor * value) : value;
|
||||
}
|
||||
group.time[row] = value;
|
||||
}
|
||||
|
||||
// 各信号通道。
|
||||
for (std::size_t c = 0; c < group.channels.size(); ++c)
|
||||
{
|
||||
if (c == masterIndex)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
const ChannelSpec& spec = group.channels[c];
|
||||
double value = DecodeRawValue(record, recordBytes, spec);
|
||||
if (spec.allInvalid)
|
||||
{
|
||||
value = kMissingValue;
|
||||
}
|
||||
else if (spec.hasInvalidBit)
|
||||
{
|
||||
const std::size_t byteIndex = spec.invalidBitPos / 8u;
|
||||
if (byteIndex < recordBytes &&
|
||||
((record[byteIndex] >> (spec.invalidBitPos % 8u)) & 1u) != 0u)
|
||||
{
|
||||
value = kMissingValue;
|
||||
}
|
||||
}
|
||||
if (std::isfinite(value))
|
||||
{
|
||||
value = spec.linearConversion ? (spec.offset + spec.factor * value) : value;
|
||||
}
|
||||
group.values[c][row] = value;
|
||||
}
|
||||
}
|
||||
done += wantRecords;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 从通道组里选出时间主通道。
|
||||
* @return 主通道下标；找不到时返回 `channels.size()`（表示没有可用时间轴）。
|
||||
*/
|
||||
std::size_t SelectMasterChannel(const std::vector<ChannelSpec>& channels)
|
||||
{
|
||||
for (std::size_t i = 0; i < channels.size(); ++i)
|
||||
{
|
||||
if (channels[i].syncMaster && channels[i].numeric)
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
for (std::size_t i = 0; i < channels.size(); ++i)
|
||||
{
|
||||
if (!channels[i].numeric)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
std::wstring lower;
|
||||
lower.reserve(channels[i].name.size());
|
||||
for (const wchar_t c : channels[i].name)
|
||||
{
|
||||
lower.push_back((c >= L'A' && c <= L'Z') ? static_cast<wchar_t>(c - L'A' + L'a') : c);
|
||||
}
|
||||
if (lower == L"time" || lower == L"t" || lower == L"timestamp")
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return channels.size();
|
||||
}
|
||||
} // namespace
|
||||
|
||||
bool LoadMf4Source(const std::wstring& filePath, LoadedSource& source, std::wstring& error,
|
||||
const LoadProgress& progress)
|
||||
{
|
||||
source = LoadedSource();
|
||||
error.clear();
|
||||
|
||||
MdfFile file;
|
||||
if (!file.Open(filePath, error))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
const std::size_t slashPos = filePath.find_last_of(L"\\/");
|
||||
source.sourceName = (slashPos == std::wstring::npos) ? filePath : filePath.substr(slashPos + 1);
|
||||
|
||||
// 头块 → 第一个数据组。
|
||||
std::uint64_t hd = 0;
|
||||
{
|
||||
char id[5] = {};
|
||||
// 头块通常紧跟在 64 字节 ID 块之后；用一个小的扫描窗口定位，兼容前置填充。
|
||||
for (std::uint64_t offset = 24; offset + 64 <= file.Size() && offset < 4096; offset += 8)
|
||||
{
|
||||
if (file.BlockId(offset, id) && std::memcmp(id, "##HD", 4) == 0)
|
||||
{
|
||||
hd = offset;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (hd == 0)
|
||||
{
|
||||
error = L"未找到 MDF 头块（##HD）。";
|
||||
return false;
|
||||
}
|
||||
|
||||
const std::uint64_t firstDg = file.Link(hd, 0);
|
||||
std::size_t groupCount = 0;
|
||||
WalkChain(file, firstDg, "##DG", kMaxGroups,
|
||||
[&](std::uint64_t dg)
|
||||
{
|
||||
++groupCount;
|
||||
const std::uint64_t cg = file.Link(dg, 1);
|
||||
const std::uint64_t dt = file.Link(dg, 2);
|
||||
if (!file.IsBlock(cg, "##CG") || !file.IsBlock(dt, "##DT"))
|
||||
{
|
||||
return true; // 跳过不完整的数据组
|
||||
}
|
||||
|
||||
const std::uint64_t cgData = file.DataOffset(cg);
|
||||
const std::uint64_t cycles = file.U64(cgData + 8);
|
||||
if (cycles == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
const std::uint64_t payload = file.BlockLength(dt) - (file.DataOffset(dt) - dt);
|
||||
|
||||
// 解析通道链。
|
||||
std::vector<ChannelSpec> channels;
|
||||
WalkChain(file, file.Link(cg, 1), "##CN", kMaxChannelsPerGroup,
|
||||
[&](std::uint64_t cn)
|
||||
{
|
||||
ChannelSpec spec;
|
||||
if (ParseChannel(file, cn, spec))
|
||||
{
|
||||
channels.push_back(std::move(spec));
|
||||
}
|
||||
return true;
|
||||
});
|
||||
if (channels.empty())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
// 记录长度：优先用「数据块大小 / 记录数」反推（最可靠），
|
||||
// 否则按通道覆盖的位宽向上取整到 4 字节。
|
||||
std::size_t recordBytes = 0;
|
||||
if (payload % cycles == 0 && payload / cycles > 0)
|
||||
{
|
||||
recordBytes = static_cast<std::size_t>(payload / cycles);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::size_t bits = 0;
|
||||
for (const ChannelSpec& spec : channels)
|
||||
{
|
||||
bits = std::max(bits, spec.bitOffset + spec.bitCount);
|
||||
}
|
||||
recordBytes = (bits + 31u) / 32u * 4u;
|
||||
}
|
||||
if (recordBytes == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
const std::size_t masterIndex = SelectMasterChannel(channels);
|
||||
if (masterIndex >= channels.size())
|
||||
{
|
||||
return true; // 没有可用时间轴通道
|
||||
}
|
||||
|
||||
ChannelGroupData group;
|
||||
group.timeName = channels[masterIndex].name;
|
||||
if (group.timeName.empty())
|
||||
{
|
||||
group.timeName = L"time";
|
||||
}
|
||||
group.channels = std::move(channels);
|
||||
if (!ReadChannelGroupRecords(file, dt, cycles, recordBytes, masterIndex, group))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
// 组织成一个时间轴块：时间列 + 其余数值通道。
|
||||
TableBlock block;
|
||||
block.timeHeader = group.timeName;
|
||||
block.table.headers.push_back(group.timeName);
|
||||
block.table.columns.push_back(std::move(group.time));
|
||||
for (std::size_t c = 0; c < group.channels.size(); ++c)
|
||||
{
|
||||
if (c == masterIndex || !group.channels[c].numeric)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
std::wstring name = group.channels[c].name;
|
||||
if (name.empty())
|
||||
{
|
||||
name = L"Channel" + std::to_wstring(c + 1);
|
||||
}
|
||||
block.table.headers.push_back(name);
|
||||
block.table.columns.push_back(std::move(group.values[c]));
|
||||
}
|
||||
if (block.table.columns.size() < 2)
|
||||
{
|
||||
return true; // 只有时间列：没有可绘制信号
|
||||
}
|
||||
block.table.rowCount = static_cast<std::size_t>(cycles);
|
||||
source.blocks.push_back(std::move(block));
|
||||
|
||||
if (progress)
|
||||
{
|
||||
LoadProgressInfo info;
|
||||
info.ratio = (groupCount > 0) ? std::min(1.0, static_cast<double>(groupCount) / 64.0)
|
||||
: 0.0;
|
||||
info.hasBytes = false;
|
||||
if (!progress(info))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
});
|
||||
|
||||
if (source.blocks.empty())
|
||||
{
|
||||
error = L"未在文件中找到可绘制的数值通道。";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (progress)
|
||||
{
|
||||
LoadProgressInfo info;
|
||||
info.ratio = 1.0;
|
||||
progress(info);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace jdi
|
||||
Reference in new issue
Block a user