DeepSeek V4.1 Flash
75f0fafd41
1) .mat（BIG_MAT.mat 1.29GB / 5 信号 x 16,142,471 采样）
旧链路同时驻留三份内存：整文件 fread 进 vector、整个数据集解压成字节数组、再 memcpy 成
double；外加 streams 缓存与每条信号各一份时间列拷贝。实测私有内存 +1233.9MB、117s。
现改为：
- MatHdf5::Open 用 CreateFileW + CreateFileMappingW + MapViewOfFile（MappedBytes 只读视图，
解析代码零改动；虚拟地址不等于物理内存，未访问页不驻留）；
- 新增 ReadDatasetInfo（只读元信息）+ StreamDataset(ByteSink)（连续布局 4MB 切片、
分块布局逐 chunk inflate）+ ReadDoubleStream（SDI #data# 字节流按 8 字节一组直接写 double，
7 字节尾巴处理非 8 对齐 chunk）；ReadNumbers 改为流式转换；
- MatLoader 先收集信号清单，再按（分组，时间流）合并为一个 TableBlock：时间列按内容去重、
数据列直接 move；进度改成 0-0.02 映射 / 0.02-0.98 逐流解码 / 1.0。
结果：117.3s -> 12.5s，私有内存 +1233.9MB -> +740.4MB（最终列数据 738.9MB）。
关键性能修正：SDI 的 #data# 是 dims=[N]、chunk=[N,1]，归一化后每行只有 1 字节；旧的逐行回调
（且每行分配 coordinate 向量）只有 11MB/s。把目标连续的行合并成一次回调后约 110MB/s。
顺带把 inflate 的 Huffman 解码改成 9 位快查表，并抽到新的 Deflate.hpp/.cpp 供 MF4 复用。
2) MDF4 数据块
Problem-MF4.mf4 的第二个数据组把记录写在 ##DL（数据列表，两个 ##DT：131040+504 字节）
里，旧实现只认 ##DT，整组被跳过，于是 8 个信号只读出 4 个。
新增 CollectDataSegments（递归展开 ##DL / ##HL，叶子识别 ##DT / ##DV / ##DZ）与
ReadRecordSegments（跨段拼接、压缩段先 inflate、非压缩段仍按 4MB 分块读），
压缩段的记录长度改用 max(cg_record_id_len*8, 各通道 bitOffset+bitCount) 推算（载荷是压缩长度）。
实测 8 个信号：gVP_WindowLearnSt[0] 94 行、gVR_WinOpenReq[0] 9396 行，时间列单调。
##SD（已排序数据）仍未实现，这类数据组会被跳过。
另按要求只做检查、不改代码：该文件中 gVP_WindowLearnSt[0] 与 gVR_WinOpenReq[0] 都存在
值枚举文本（##CC，cc_type=7；links[4+i] 对应 cc_val[i]），清单已写入 Documents/agent_mem.md。
3) 光标数据点标记
光标的时间读数与差值胶囊绘制在绘图区底部、且在取值标注之后绘制，靠近底部的数据点圆点
会被完全盖住。新增 MarkerCoveredByCursorLabel（圆心落入面板或重叠面积达到半个圆）
与 CoverHiddenMarker（改成向下的三角、锚点放到面板上沿上方），在原始信号与派生曲线胶囊
两处调用，语义与“数据点在视界下方”一致。
验证（全部离屏：SW_HIDE 窗口 + 只注入合成消息 + BELOW_NORMAL，不占用鼠标键盘屏幕）：
- 新增 .preflight/round4check 34/34；A/B：临时禁用 ##DL 支持 => 2 项如实失败；
临时禁用 CoverHiddenMarker => 3 项如实失败（含像素断言为 0）；
- 回归：.preflight/round3check 31/31、editcheck 20/20、check 137/137；
- make release / make debug 零警告；Build/Release/Target.exe 785,920 字节（< 800KB）。
649 lines
20 KiB
C++
649 lines
20 KiB
C++
// MATLAB `.mat`（v7.3 / HDF5）加载器。
|
||
//
|
||
// 支持两种内容（详见 MatLoader.hpp 的说明）：
|
||
// * Simulink SDI / `SimulationData.Dataset` 导出：`#refs#` 里的元素图 + `#sigstream#` 的样本流；
|
||
// * 普通 v7.3 变量：数值矩阵按"列 = 信号、行 = 采样"读取（时间轴 = 采样序号）。
|
||
#include "MatLoader.hpp"
|
||
|
||
#include "MatH5.hpp"
|
||
|
||
#include <algorithm>
|
||
#include <cstdint>
|
||
#include <cstring>
|
||
#include <map>
|
||
#include <set>
|
||
#include <string>
|
||
#include <vector>
|
||
|
||
namespace jdi
|
||
{
|
||
|
||
namespace
|
||
{
|
||
/** @brief 一个 SDI 信号（或子数据集）的解析结果。 */
|
||
struct SdiElement
|
||
{
|
||
bool isSignal = false;
|
||
bool isDataset = false;
|
||
std::wstring name;
|
||
std::vector<std::uint64_t> children; /**< 子数据集元素的引用目标。 */
|
||
int dataStream = -1; /**< 数据流下标。 */
|
||
int timeStream = -1; /**< 时间流下标。 */
|
||
};
|
||
|
||
std::wstring TrimNumber(double value)
|
||
{
|
||
wchar_t buffer[64] = {};
|
||
if (value == static_cast<double>(static_cast<long long>(value)))
|
||
{
|
||
std::swprintf(buffer, 64, L"%lld", static_cast<long long>(value));
|
||
}
|
||
else
|
||
{
|
||
std::swprintf(buffer, 64, L"%g", value);
|
||
}
|
||
return buffer;
|
||
}
|
||
|
||
/** @brief 去掉文件名中的扩展名。 */
|
||
std::wstring StemOf(const std::wstring& path)
|
||
{
|
||
const std::size_t slash = path.find_last_of(L"\\/");
|
||
std::wstring name = (slash == std::wstring::npos) ? path : path.substr(slash + 1);
|
||
const std::size_t dot = name.find_last_of(L'.');
|
||
if (dot != std::wstring::npos && dot > 0)
|
||
{
|
||
name.resize(dot);
|
||
}
|
||
return name;
|
||
}
|
||
|
||
/** @brief 读取一个「流」的全部 double 样本（`#sigstream#/<n>/#data#`）。 */
|
||
bool ReadStream(const MatHdf5& file, std::uint64_t streamObject, std::vector<double>& out)
|
||
{
|
||
out.clear();
|
||
const std::uint64_t data = file.Member(streamObject, "#data#");
|
||
if (data == 0)
|
||
{
|
||
return false;
|
||
}
|
||
// ⚠️ SDI 的 `#data#` 是**字节流**（`uint8` 数据集，长度 = 采样数 × 8），
|
||
// 而不是 double 数据集：必须按 8 字节一组重新解释成 double。
|
||
// `ReadDoubleStream` 会逐 chunk 解压并**直接写入** `out`：
|
||
// 不生成“整个数据集的未压缩字节”，也不做第二次拷贝（GB 级文件的关键）。
|
||
return file.ReadDoubleStream(data, out) && !out.empty();
|
||
}
|
||
|
||
/** @brief 解析 `#refs#` 里的一个元素（信号 / 子数据集）。 */
|
||
void ParseElement(const MatHdf5& file, std::uint64_t address, SdiElement& element)
|
||
{
|
||
element = SdiElement();
|
||
std::wstring elementType;
|
||
file.ReadText(file.Member(address, "ElementType"), elementType);
|
||
file.ReadText(file.Member(address, "Name"), element.name);
|
||
const std::uint64_t values = file.Member(address, "Values");
|
||
if (elementType == L"dataset")
|
||
{
|
||
element.isDataset = true;
|
||
if (values != 0)
|
||
{
|
||
file.ReadReferences(values, element.children);
|
||
}
|
||
return;
|
||
}
|
||
element.isSignal = true;
|
||
if (values == 0)
|
||
{
|
||
return;
|
||
}
|
||
// 名字为空时退回 timeseries 自己的 Name。
|
||
if (element.name.empty())
|
||
{
|
||
file.ReadText(file.Member(values, "Name"), element.name);
|
||
}
|
||
std::vector<double> numbers;
|
||
if (file.ReadNumbers(file.Member(values, "DataR2"), numbers) && !numbers.empty())
|
||
{
|
||
element.dataStream = static_cast<int>(numbers.front());
|
||
}
|
||
numbers.clear();
|
||
if (file.ReadNumbers(file.Member(values, "TimeR2"), numbers) && !numbers.empty())
|
||
{
|
||
element.timeStream = static_cast<int>(numbers.front());
|
||
}
|
||
}
|
||
|
||
/** @brief 追加一条信号（时间 + 数值）到某个分组的时间轴块集合。 */
|
||
void AppendSignal(LoadedSource& source, const std::wstring& name, std::vector<double>&& time,
|
||
std::vector<double>&& values)
|
||
{
|
||
if (time.empty() || values.empty())
|
||
{
|
||
return;
|
||
}
|
||
TableBlock block;
|
||
block.timeHeader = L"time";
|
||
DataTable& table = block.table;
|
||
table.headers.push_back(L"time");
|
||
table.headers.push_back(name);
|
||
table.rowCount = std::min(time.size(), values.size());
|
||
time.resize(table.rowCount);
|
||
values.resize(table.rowCount);
|
||
table.columns.push_back(std::move(time));
|
||
table.columns.push_back(std::move(values));
|
||
source.blocks.push_back(std::move(block));
|
||
}
|
||
|
||
/** @brief 加载进度上报器（`.mat` 解析拆成“读文件”与“解码每个样本流”两段）。 */
|
||
struct ProgressReporter
|
||
{
|
||
const LoadProgress* sink = nullptr; /**< 目标回调（可空）。 */
|
||
double low = 0.0; /**< 本阶段占的进度区间下界。 */
|
||
double high = 1.0; /**< 本阶段占的进度区间上界。 */
|
||
std::uint64_t read = 0; /**< 已读字节。 */
|
||
std::uint64_t total = 0; /**< 总字节。 */
|
||
|
||
/** @brief 上报一个 0-1 的阶段内进度（向宿主传递字节数与百分比）。 */
|
||
bool Report(double fraction) const
|
||
{
|
||
if (sink == nullptr || !(*sink))
|
||
{
|
||
return true;
|
||
}
|
||
if (fraction < 0.0)
|
||
{
|
||
fraction = 0.0;
|
||
}
|
||
if (fraction > 1.0)
|
||
{
|
||
fraction = 1.0;
|
||
}
|
||
LoadProgressInfo info;
|
||
info.ratio = low + (high - low) * fraction;
|
||
// 总字节已知时一并上报（遮罩层据此显示“已加载 / 总大小”）。
|
||
info.hasBytes = (total > 0);
|
||
info.bytesRead = (total > 0) ? read : 0;
|
||
info.totalBytes = total;
|
||
return (*sink)(info);
|
||
}
|
||
};
|
||
|
||
/** @brief SDI（`SimulationData.Dataset`）结构的分组读取。 */
|
||
bool LoadSdi(const MatHdf5& file, std::uint64_t refs, std::uint64_t sigstream,
|
||
const std::wstring& stem, std::vector<LoadedSourceGroup>& groups,
|
||
std::wstring& error, const ProgressReporter& reporter)
|
||
{
|
||
// 1) 枚举 `#refs#` 里的全部元素。
|
||
std::map<std::uint64_t, SdiElement> elements;
|
||
for (const auto& member : file.Members(refs))
|
||
{
|
||
if (file.IsDataset(member.second))
|
||
{
|
||
continue;
|
||
}
|
||
SdiElement element;
|
||
ParseElement(file, member.second, element);
|
||
if (element.isSignal || element.isDataset)
|
||
{
|
||
elements[member.second] = std::move(element);
|
||
}
|
||
}
|
||
if (elements.empty())
|
||
{
|
||
error = L"文件中没有 Simulink 数据元素。";
|
||
return false;
|
||
}
|
||
|
||
// 2) 找出"根"数据集：没有被任何其它数据集当作子元素引用的那些。
|
||
std::set<std::uint64_t> childAddresses;
|
||
for (const auto& entry : elements)
|
||
{
|
||
for (const std::uint64_t child : entry.second.children)
|
||
{
|
||
childAddresses.insert(child);
|
||
}
|
||
}
|
||
std::vector<std::uint64_t> roots;
|
||
for (const auto& entry : elements)
|
||
{
|
||
if (!entry.second.isDataset)
|
||
{
|
||
continue;
|
||
}
|
||
if (childAddresses.count(entry.first) == 0)
|
||
{
|
||
roots.push_back(entry.first);
|
||
}
|
||
}
|
||
if (roots.empty())
|
||
{
|
||
// 没有任何子数据集关系：所有信号归入同一组。
|
||
for (const auto& entry : elements)
|
||
{
|
||
if (entry.second.isSignal)
|
||
{
|
||
roots.push_back(entry.first);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 3) 深度优先遍历：路径上的数据集名字用 `-` 连接成分组名。
|
||
struct Pending
|
||
{
|
||
std::uint64_t address = 0;
|
||
std::vector<std::wstring> path;
|
||
int depth = 0;
|
||
};
|
||
std::vector<Pending> stack;
|
||
for (const std::uint64_t root : roots)
|
||
{
|
||
const auto found = elements.find(root);
|
||
if (found == elements.end())
|
||
{
|
||
continue;
|
||
}
|
||
Pending pending;
|
||
pending.address = root;
|
||
if (found->second.isDataset && !found->second.name.empty())
|
||
{
|
||
pending.path.push_back(found->second.name);
|
||
}
|
||
stack.push_back(std::move(pending));
|
||
}
|
||
|
||
// ⚠️ **先收集信号清单、再解码**（用户 2026-10-19 要求：边解析边填充）：
|
||
// * 旧实现把**每条**信号的时间列和时间流各拷一份（`streams` 缓存 + `AppendSignal`
|
||
// 里的整份复制）⇒ GB 级文件会出现“文件 + 解压字节 + 每条信号两份 double”叠加；
|
||
// * 现在按「分组 + 时间流」合并成一个 `TableBlock`：时间列只存一份、信号列直接
|
||
// `std::move` 进数据模型，且每条数据流解码完立刻进入最终缓冲。
|
||
struct PendingSignal
|
||
{
|
||
std::wstring groupName;
|
||
std::wstring signalName;
|
||
int timeStream = -1;
|
||
int dataStream = -1;
|
||
};
|
||
std::vector<PendingSignal> signals;
|
||
int unnamedSignals = 0;
|
||
while (!stack.empty())
|
||
{
|
||
Pending pending = std::move(stack.back());
|
||
stack.pop_back();
|
||
const auto found = elements.find(pending.address);
|
||
if (found == elements.end())
|
||
{
|
||
continue;
|
||
}
|
||
const SdiElement& element = found->second;
|
||
if (element.isDataset)
|
||
{
|
||
for (const std::uint64_t child : element.children)
|
||
{
|
||
Pending next;
|
||
next.address = child;
|
||
next.path = pending.path;
|
||
const auto childElement = elements.find(child);
|
||
if (childElement != elements.end() && childElement->second.isDataset &&
|
||
!childElement->second.name.empty())
|
||
{
|
||
next.path.push_back(childElement->second.name);
|
||
}
|
||
stack.push_back(std::move(next));
|
||
}
|
||
continue;
|
||
}
|
||
if (!element.isSignal || element.dataStream < 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
PendingSignal signal;
|
||
for (const std::wstring& piece : pending.path)
|
||
{
|
||
if (!signal.groupName.empty())
|
||
{
|
||
signal.groupName += L"-";
|
||
}
|
||
signal.groupName += piece;
|
||
}
|
||
if (signal.groupName.empty())
|
||
{
|
||
signal.groupName = stem;
|
||
}
|
||
signal.signalName = element.name;
|
||
if (signal.signalName.empty())
|
||
{
|
||
signal.signalName = L"信号" + std::to_wstring(++unnamedSignals);
|
||
}
|
||
signal.timeStream = element.timeStream;
|
||
signal.dataStream = element.dataStream;
|
||
signals.push_back(std::move(signal));
|
||
}
|
||
|
||
// 2) 解码：每个（分组，时间流）一个时间轴块；每条数据流只解码一次并直接进列。
|
||
std::map<std::wstring, std::size_t> groupIndex;
|
||
std::map<std::pair<std::wstring, int>, std::size_t> blockIndex;
|
||
std::size_t decoded = 0;
|
||
|
||
const auto reportStream = [&]()
|
||
{
|
||
++decoded;
|
||
const double fraction = (signals.empty())
|
||
? 1.0
|
||
: static_cast<double>(decoded) /
|
||
static_cast<double>(signals.size());
|
||
return reporter.Report(std::min(1.0, fraction));
|
||
};
|
||
|
||
for (PendingSignal& signal : signals)
|
||
{
|
||
// 分组（每个分组名对应一个 `LoadedSourceGroup`）。
|
||
std::size_t groupSlot = 0;
|
||
const auto existing = groupIndex.find(signal.groupName);
|
||
if (existing == groupIndex.end())
|
||
{
|
||
LoadedSourceGroup group;
|
||
group.name = signal.groupName;
|
||
group.source.sourceName = signal.groupName;
|
||
groups.push_back(std::move(group));
|
||
groupSlot = groups.size() - 1;
|
||
groupIndex.emplace(signal.groupName, groupSlot);
|
||
}
|
||
else
|
||
{
|
||
groupSlot = existing->second;
|
||
}
|
||
LoadedSource& source = groups[groupSlot].source;
|
||
|
||
// 数据列：直接解码到最终 vector（不再经过 `Dataset.data` 的整块字节）。
|
||
std::vector<double> values;
|
||
const std::uint64_t dataObject = file.Member(sigstream, std::to_string(signal.dataStream));
|
||
if (dataObject == 0 || !ReadStream(file, dataObject, values) || values.empty())
|
||
{
|
||
if (!reportStream())
|
||
{
|
||
return false;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 找（或建）该信号所属的时间轴块。
|
||
const std::pair<std::wstring, int> key{signal.groupName, signal.timeStream};
|
||
std::size_t blockSlot = 0;
|
||
const auto blockFound = blockIndex.find(key);
|
||
if (blockFound == blockIndex.end())
|
||
{
|
||
TableBlock block;
|
||
block.timeHeader = L"time";
|
||
std::vector<double> time;
|
||
bool haveTime = false;
|
||
if (signal.timeStream >= 0)
|
||
{
|
||
const std::uint64_t timeObject =
|
||
file.Member(sigstream, std::to_string(signal.timeStream));
|
||
haveTime = timeObject != 0 && ReadStream(file, timeObject, time) &&
|
||
!time.empty();
|
||
}
|
||
if (!haveTime)
|
||
{
|
||
// 时间流缺失：退化为采样序号（秒），保证信号仍可显示（长度在下面裁剪）。
|
||
time.resize(values.size());
|
||
for (std::size_t index = 0; index < values.size(); ++index)
|
||
{
|
||
time[index] = static_cast<double>(index);
|
||
}
|
||
}
|
||
|
||
// ⚠️ **时间轴按内容去重**：SDI 里每条 timeseries 都有自己的时间流，
|
||
// 但内容通常完全一致。若同一分组里已经有一模一样的时间列，就直接复用它
|
||
//（否则每条信号各存一份时间轴：1.29GB / 5 信号的文件会多占 ~500MB）。
|
||
std::size_t reused = SIZE_MAX;
|
||
for (std::size_t index = 0; index < source.blocks.size(); ++index)
|
||
{
|
||
const std::vector<double>& existingTime = source.blocks[index].table.columns[0];
|
||
if (existingTime.size() != time.size())
|
||
{
|
||
continue;
|
||
}
|
||
if (time.empty() ||
|
||
std::memcmp(existingTime.data(), time.data(),
|
||
time.size() * sizeof(double)) == 0)
|
||
{
|
||
reused = index;
|
||
break;
|
||
}
|
||
}
|
||
if (reused != SIZE_MAX)
|
||
{
|
||
blockIndex.emplace(key, reused);
|
||
blockSlot = reused;
|
||
}
|
||
else
|
||
{
|
||
block.table.headers.push_back(block.timeHeader);
|
||
block.table.columns.push_back(std::move(time));
|
||
source.blocks.push_back(std::move(block));
|
||
blockSlot = source.blocks.size() - 1;
|
||
blockIndex.emplace(key, blockSlot);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
blockSlot = blockFound->second;
|
||
}
|
||
|
||
TableBlock& block = source.blocks[blockSlot];
|
||
// 时间列长度与信号不一致（损坏 / 异构）⇒ 单独成块，用采样序号当时间，
|
||
// 保持“每条信号都能显示”的既有语义，而不是把数据截掉或错位。
|
||
if (block.table.columns[0].size() != values.size())
|
||
{
|
||
TableBlock own;
|
||
own.timeHeader = L"time";
|
||
std::vector<double> time(values.size());
|
||
for (std::size_t index = 0; index < values.size(); ++index)
|
||
{
|
||
time[index] = static_cast<double>(index);
|
||
}
|
||
own.table.headers.push_back(own.timeHeader);
|
||
own.table.columns.push_back(std::move(time));
|
||
own.table.headers.push_back(signal.signalName);
|
||
own.table.columns.push_back(std::move(values));
|
||
source.blocks.push_back(std::move(own));
|
||
if (!reportStream())
|
||
{
|
||
return false;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
block.table.headers.push_back(signal.signalName);
|
||
block.table.columns.push_back(std::move(values));
|
||
if (!reportStream())
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 3) 统一行数：同一块内取各列最小长度（时间流与数据流长度不一致时按最小裁剪）。
|
||
for (LoadedSourceGroup& group : groups)
|
||
{
|
||
for (TableBlock& block : group.source.blocks)
|
||
{
|
||
std::size_t rows = SIZE_MAX;
|
||
for (const std::vector<double>& column : block.table.columns)
|
||
{
|
||
rows = std::min(rows, column.size());
|
||
}
|
||
if (rows == SIZE_MAX)
|
||
{
|
||
rows = 0;
|
||
}
|
||
for (std::vector<double>& column : block.table.columns)
|
||
{
|
||
if (column.size() > rows)
|
||
{
|
||
column.resize(rows);
|
||
}
|
||
}
|
||
block.table.rowCount = rows;
|
||
}
|
||
}
|
||
|
||
if (groups.empty())
|
||
{
|
||
error = L"文件中没有可用的信号数据。";
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/** @brief 普通 v7.3 变量：数值矩阵 / 结构体。 */
|
||
void LoadPlainObject(const MatHdf5& file, std::uint64_t address, const std::wstring& name,
|
||
LoadedSource& source)
|
||
{
|
||
if (file.IsDataset(address))
|
||
{
|
||
std::vector<double> numbers;
|
||
if (!file.ReadNumbers(address, numbers) || numbers.empty())
|
||
{
|
||
return;
|
||
}
|
||
MatHdf5::Dataset dataset;
|
||
file.ReadDataset(address, dataset);
|
||
std::size_t rows = 1;
|
||
std::size_t columns = 1;
|
||
if (dataset.dims.size() >= 2)
|
||
{
|
||
rows = dataset.dims[0];
|
||
columns = dataset.dims[1];
|
||
}
|
||
else if (dataset.dims.size() == 1)
|
||
{
|
||
rows = dataset.dims[0];
|
||
}
|
||
if (rows == 0 || columns == 0 || rows * columns != numbers.size())
|
||
{
|
||
return;
|
||
}
|
||
// 列 = 信号、行 = 采样（与 MATLAB 的列优先存储一致）。
|
||
for (std::size_t column = 0; column < columns; ++column)
|
||
{
|
||
std::vector<double> values(rows);
|
||
for (std::size_t row = 0; row < rows; ++row)
|
||
{
|
||
values[row] = numbers[column * rows + row];
|
||
}
|
||
std::vector<double> time(rows);
|
||
for (std::size_t row = 0; row < rows; ++row)
|
||
{
|
||
time[row] = static_cast<double>(row);
|
||
}
|
||
const std::wstring signalName =
|
||
(columns == 1) ? name : (name + L"(" + TrimNumber(static_cast<double>(column + 1)) + L")");
|
||
AppendSignal(source, signalName, std::move(time), std::move(values));
|
||
}
|
||
return;
|
||
}
|
||
// 结构体：字段各自作为信号（子结构体递归）。
|
||
for (const auto& member : file.Members(address))
|
||
{
|
||
if (member.first.empty())
|
||
{
|
||
continue;
|
||
}
|
||
std::wstring childName(member.first.begin(), member.first.end());
|
||
LoadPlainObject(file, member.second, childName, source);
|
||
}
|
||
}
|
||
} // namespace
|
||
|
||
bool LoadMatSourceGroups(const std::wstring& filePath, std::vector<LoadedSourceGroup>& groups,
|
||
std::wstring& error, const LoadProgress& progress)
|
||
{
|
||
error.clear();
|
||
groups.clear();
|
||
MatHdf5 file;
|
||
|
||
// ------------------------------------------------------------------
|
||
// 进度拆成三段：
|
||
// 0.00 – 0.02 映射文件（内存映射，几乎瞬时；遮罩层仍能看到“已加载 = 总大小”）
|
||
// 0.02 – 0.98 逐条解码样本流（每个流解压后直接填进数据模型，含解压开销）
|
||
// 0.98 – 1.00 收尾
|
||
// ⚠️ 旧实现把 0–0.55 全给了“读文件字节”（因为旧实现真的整文件读入）；
|
||
// 现在改成内存映射后那一段几乎没有耗时，若不调整权重，进度条会“瞬间跳到 55% 再慢慢走”。
|
||
// ------------------------------------------------------------------
|
||
ProgressReporter readReporter;
|
||
readReporter.sink = &progress;
|
||
readReporter.low = 0.0;
|
||
readReporter.high = 0.02;
|
||
const MatHdf5::OpenProgress openProgress =
|
||
[&readReporter](std::uint64_t bytesRead, std::uint64_t totalBytes) -> bool
|
||
{
|
||
readReporter.read = bytesRead;
|
||
readReporter.total = totalBytes;
|
||
return readReporter.Report(totalBytes > 0 ? static_cast<double>(bytesRead) /
|
||
static_cast<double>(totalBytes)
|
||
: 0.0);
|
||
};
|
||
if (!file.Open(filePath, error, openProgress))
|
||
{
|
||
return false; // 用户取消时 `error` 为空
|
||
}
|
||
ProgressReporter parseReporter;
|
||
parseReporter.sink = &progress;
|
||
parseReporter.low = 0.02;
|
||
parseReporter.high = 0.98;
|
||
parseReporter.read = readReporter.total;
|
||
parseReporter.total = 0; // 字节已读完：本阶段只报百分比
|
||
if (!parseReporter.Report(0.0))
|
||
{
|
||
error.clear();
|
||
return false;
|
||
}
|
||
|
||
const std::wstring stem = StemOf(filePath);
|
||
|
||
const std::uint64_t refs = file.Member(file.Root(), "#refs#");
|
||
const std::uint64_t sigstream = file.Member(file.Root(), "#sigstream#");
|
||
if (refs != 0 && sigstream != 0)
|
||
{
|
||
if (!LoadSdi(file, refs, sigstream, stem, groups, error, parseReporter))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
LoadedSourceGroup group;
|
||
group.source.sourceName = stem;
|
||
for (const auto& member : file.Members(file.Root()))
|
||
{
|
||
if (member.first.empty() || member.first[0] == '#')
|
||
{
|
||
continue;
|
||
}
|
||
std::wstring name(member.first.begin(), member.first.end());
|
||
LoadPlainObject(file, member.second, name, group.source);
|
||
}
|
||
if (!group.source.HasData())
|
||
{
|
||
error = L".mat 文件中没有可用的数值数据。";
|
||
return false;
|
||
}
|
||
groups.push_back(std::move(group));
|
||
}
|
||
|
||
if (progress)
|
||
{
|
||
LoadProgressInfo info;
|
||
info.ratio = 1.0;
|
||
info.hasBytes = (readReporter.total > 0);
|
||
info.bytesRead = readReporter.total;
|
||
info.totalBytes = readReporter.total;
|
||
progress(info);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
} // namespace jdi
|